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
  24 //_________________________________________________________________________
  25 //  A singleton. This class should be used in the analysis stage to get
  26 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
  27 //  instead of directly reading them from galice.root file. This container
  28 //  ensures, that one reads Digits, made of these particular digits, RecPoints,
  29 //  made of these particular RecPoints, TrackSegments and RecParticles.
  30 //  This becomes non trivial if there are several identical branches, produced with
  31 //  different set of parameters.
  32 //
  33 //  An example of how to use (see also class AliPHOSAnalyser):
  34 //  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
  35 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
  36 //     AliPHOSRecParticle * part = gime->RecParticle(1) ;
  37 //     ................
  38 //  please->GetEvent(event) ;    // reads new event from galice.root
  39 //
  40 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  41 //*--         Completely redesigned by Dmitri Peressounko March 2001
  42 //
  43 //*-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
  44 //*--         systematic usage of TFolders without changing the interface
  45 //////////////////////////////////////////////////////////////////////////////
  46
  47
  48 // --- ROOT system ---
  49
  50 #include "TFile.h"
  51 #include "TTree.h"
  52 #include "TROOT.h"
  53 #include "TObjString.h"
  54 #include "TFolder.h"
  55 #include "TParticle.h"
  56
  57 // --- Standard library ---
  58 #include <iostream.h>
  59
  60 // --- AliRoot header files ---
  61
  62 #include "AliRun.h"
  63 #include "AliConfig.h"
  64 #include "AliPHOSGetter.h"
  65 #include "AliPHOS.h"
  66 #include "AliPHOSDigitizer.h"
  67 #include "AliPHOSSDigitizer.h"
  68 #include "AliPHOSClusterizerv1.h"
  69 #include "AliPHOSTrackSegmentMakerv1.h"
  70 #include "AliPHOSTrackSegment.h"
  71 #include "AliPHOSPIDv1.h"
  72 #include "AliPHOSGeometry.h"
  73
  74 ClassImp(AliPHOSGetter)
  75
  76   AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
  77   TFile * AliPHOSGetter::fFile = 0 ;
  78
  79 //____________________________________________________________________________
  80 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle )
  81 {
  82   //Initialize  all lists
  83
  84   fDebug = 0 ;
  85
  86   fHeaderFile         = headerFile ;
  87   fBranchTitle        = branchTitle ;
  88   fSDigitsTitle       = branchTitle ;
  89   fDigitsTitle        = branchTitle ;
  90   fRecPointsTitle     = branchTitle ;
  91   fRecParticlesTitle  = branchTitle ;
  92   fTrackSegmentsTitle = branchTitle ;
  93
  94   fPrimaries = new TObjArray(1) ;
  95
  96   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules"));
  97   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data"));
  98   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits"));
  99   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits"));
 100   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data"));
 101   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData"));
 102   fQAFolder        = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA"));
 103   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ;
 104
 105   fFailed = kFALSE ;
 106
 107   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
 108     //open headers file
 109     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
 110
 111     if(!fFile) {    //if file was not opened yet, read gAlice
 112       if ( fHeaderFile.Contains("_") ) {
 113         cerr << "AliPHOSGetter::AliPHOSGetter -> Invalid file name (_ not allowed) " << fHeaderFile.Data() << endl ;
 114         abort() ;
 115      }
 116       fFile = TFile::Open(fHeaderFile.Data(),"update") ;
 117       if (!fFile->IsOpen()) {
 118         cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot open " << fHeaderFile.Data() << endl ;
 119         fFailed = kTRUE ;
 120         return ;
 121       }
 122       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
 123     }
 124   }
 125
 126   if (!gAlice) {
 127     cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ;
 128     fFailed = kTRUE ;
 129     return ;
 130   }
 131   if (!PHOS()) {
 132     if (fDebug)
 133       cout << "INFO: AliPHOSGetter:AliPHOSGetter -> Posting PHOS to Folders" << endl ;
 134     if (gAlice->GetDetector("PHOS")) {
 135       AliConfig * conf = AliConfig::Instance() ;
 136       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("PHOS"))) ;
 137       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("PHOS"))) ;
 138     }
 139     else
 140       cerr << "ERROR: AliPHOSGetter:AliPHOSGetter -> detector PHOS not found" << endl ;
 141   }
 142
 143   fDebug=0;
 144 }
 145 //____________________________________________________________________________
 146 AliPHOSGetter::~AliPHOSGetter(){
 147
 148   if (fPrimaries) {
 149     fPrimaries->Delete() ;
 150     delete fPrimaries ;
 151   }
 152
 153   TFolder * phosF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
 154   TCollection * folderslist = phosF->GetListOfFolders() ;
 155   TIter next(folderslist) ;
 156   TFolder * folder = 0 ;
 157   while ( (folder = static_cast<TFolder*>(next())) )
 158     phosF->Remove(folder) ;
 159
 160   if (fFile) {
 161     fFile->Close() ;
 162     delete fFile ;
 163     fFile = 0 ;
 164   }
 165
 166 }
 167
 168
 169 //____________________________________________________________________________
 170 AliPHOSGetter * AliPHOSGetter::GetInstance()
 171 {
 172   // Returns the pointer of the unique instance already defined
 173
 174   AliPHOSGetter * rv = 0 ;
 175   if ( fgObjGetter )
 176     rv = fgObjGetter ;
 177   else
 178     cout << "AliPHOSGetter::GetInstance ERROR: not yet initialized" << endl ;
 179
 180   fFile->cd() ;
 181   return rv ;
 182 }
 183
 184 //____________________________________________________________________________
 185 AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
 186                                            const char* branchTitle)
 187 {
 188   // Creates and returns the pointer of the unique instance
 189   // Must be called only when the environment has changed
 190
 191   if ( fgObjGetter )
 192     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) &&
 193        (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0)) {
 194       fFile->cd() ;
 195       return fgObjGetter ;
 196     }
 197     else
 198       fgObjGetter->~AliPHOSGetter() ;  // delete it already exists another version
 199
 200   fgObjGetter = new AliPHOSGetter(headerFile,branchTitle) ;
 201
 202   if (fgObjGetter->HasFailed() )
 203     fgObjGetter = 0 ;
 204
 205   // Posts a few item to the white board (folders)
 206   // fgObjGetter->CreateWhiteBoard() ;
 207
 208   fFile->cd() ;
 209   return fgObjGetter ;
 210
 211 }
 212
 213 //____________________________________________________________________________
 214 void AliPHOSGetter::ListBranches(Int_t event) const
 215 {
 216
 217   TBranch * branch = 0 ;
 218   if (gAlice->GetEvent(event) == -1)
 219     return ;
 220
 221   TTree * t =  gAlice->TreeH() ;
 222   if(t){
 223     cout << "****** Hits    : " << endl ;
 224     TObjArray * lob = t->GetListOfBranches() ;
 225     TIter next(lob) ;
 226     while ( (branch = static_cast<TBranch*>(next())) )
 227       cout << "             " << branch->GetName() << endl ;
 228   }
 229
 230   t = gAlice->TreeS() ;
 231   if(t){
 232     cout << "****** SDigits : " << endl ;
 233     TObjArray * lob = t->GetListOfBranches() ;
 234     TIter next(lob) ;
 235     while ( (branch = static_cast<TBranch*>(next())) )
 236       cout << "             " << branch->GetName() << endl ;
 237   }
 238   t = gAlice->TreeD() ;
 239   if(t){
 240     cout << "****** Digits  : " << endl ;
 241     TObjArray * lob = t->GetListOfBranches() ;
 242     TIter next(lob) ;
 243     while ( (branch = static_cast<TBranch*>(next())) )
 244       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ;
 245   }
 246
 247   t = gAlice->TreeR() ;
 248   if(t){
 249     cout << "****** Recon   : " << endl ;
 250     TObjArray * lob = t->GetListOfBranches() ;
 251     TIter next(lob) ;
 252     while ( (branch = static_cast<TBranch*>(next())) )
 253       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ;
 254   }
 255 }
 256
 257 //____________________________________________________________________________
 258 void AliPHOSGetter::NewBranch(TString name, Int_t event)
 259 {
 260   fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ;
 261   Event(event) ;
 262 }
 263
 264 //____________________________________________________________________________
 265 Bool_t AliPHOSGetter::NewFile(TString name)
 266 {
 267   fHeaderFile = name ;
 268   fFile->Close() ;
 269   fFailed = kFALSE;
 270
 271   fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
 272   if(!fFile) {    //if file was not opened yet, read gAlice
 273     fFile = TFile::Open(fHeaderFile.Data(),"update") ;
 274     if (!fFile->IsOpen()) {
 275       cerr << "ERROR : AliPHOSGetter::NewFile -> Cannot open " << fHeaderFile.Data() << endl ;
 276       fFailed = kTRUE ;
 277       return fFailed ;
 278     }
 279     gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
 280   }
 281
 282   if (!gAlice) {
 283     cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ;
 284     fFailed = kTRUE ;
 285     return fFailed ;
 286   }
 287   return fFailed ;
 288 }
 289
 290 //____________________________________________________________________________
 291 const AliPHOS * AliPHOSGetter::PHOS()
 292 {
 293   // returns the PHOS object
 294   AliPHOS * phos = dynamic_cast<AliPHOS*>(fModuleFolder->FindObject("PHOS")) ;
 295   if (!phos)
 296     if (fDebug)
 297       cout << "WARNING: AliPHOSGetter::PHOS -> PHOS module not found in Folders" << endl ;
 298   return phos ;
 299 }
 300
 301 //____________________________________________________________________________
 302 const AliPHOSGeometry * AliPHOSGetter::PHOSGeometry()
 303 {
 304   AliPHOSGeometry * rv = 0 ;
 305   if (PHOS() )
 306     rv =  PHOS()->GetGeometry() ;
 307   return rv ;
 308 }
 309
 310 //____________________________________________________________________________
 311 Bool_t AliPHOSGetter::PostPrimaries(void) const
 312 {  //------- Primaries ----------------------
 313
 314   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
 315
 316   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ;
 317   if ( !primariesFolder ) {
 318     if (fDebug) {
 319       cout << "WARNING: AliPHOSGetter::Post Primaries -> Folder //" << fPrimariesFolder << "/Primaries/ not found!" << endl;
 320       cout << "INFO:    AliPHOSGetter::Post Primaries -> Adding Folder //" << fPrimariesFolder << "/Primaries/"  << endl;
 321     }
 322     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ;
 323   }
 324   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
 325   primaries->SetName("Primaries") ;
 326   primariesFolder->Add(primaries) ;
 327
 328   return kTRUE;
 329 }
 330
 331 //____________________________________________________________________________
 332 TObject** AliPHOSGetter::PrimariesRef(void) const
 333 {  //------- Primaries ----------------------
 334
 335
 336   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
 337   if ( !fPrimariesFolder ) {
 338     cerr << "ERROR: AliPHOSGetter::PrimariesRef -> Folder //" << fPrimariesFolder << " not found!" << endl;
 339     abort() ;
 340   }
 341
 342   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
 343   if ( !primariesFolder ) {
 344     cerr << "ERROR: AliPHOSGetter::PrimariesRef -> Folder //" << fPrimariesFolder << "/Primaries/ not found!" << endl;
 345     abort() ;
 346   }
 347
 348   TObject * p = primariesFolder->FindObject("Primaries") ;
 349   if(!p) {
 350     cerr << "ERROR: AliPHOSGetter::PrimariesRef -> " << primariesFolder->GetName() << "/Primaries not found !" << endl ;
 351     abort() ;
 352   }
 353   else
 354     return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
 355 }
 356
 357 //____________________________________________________________________________
 358 Bool_t AliPHOSGetter::PostHits(void) const
 359 {  //------- Hits ----------------------
 360
 361   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/Hits
 362
 363   TFolder * phosFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ;
 364   if ( !phosFolder ) {
 365     if (fDebug) {
 366       cout << "WARNING: AliPHOSGetter::Post H -> Folder //" << fHitsFolder << "/PHOS/ not found!" << endl;
 367       cout << "INFO:    AliPHOSGetter::Post H -> Adding Folder //" << fHitsFolder << "/PHOS/"  << endl;
 368     }
 369     phosFolder = fHitsFolder->AddFolder("PHOS", "Hits from PHOS") ;
 370   }
 371   TClonesArray *hits=  new TClonesArray("AliPHOSHit",1000) ;
 372   hits->SetName("Hits") ;
 373   phosFolder->Add(hits) ;
 374
 375   return kTRUE;
 376 }
 377
 378 //____________________________________________________________________________
 379 TObject** AliPHOSGetter::HitsRef(void) const
 380 {  //------- Hits ----------------------
 381
 382
 383   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/Hits
 384   if ( !fHitsFolder ) {
 385     cerr << "ERROR: AliPHOSGetter::HitsRef -> Folder //" << fHitsFolder << " not found!" << endl;
 386     abort() ;
 387   }
 388
 389   TFolder * phosFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("PHOS")) ;
 390   if ( !phosFolder ) {
 391     cerr << "ERROR: AliPHOSGetter::HitsRef -> Folder //" << fHitsFolder << "/PHOS/ not found!" << endl;
 392     abort() ;
 393   }
 394
 395   TObject * h = phosFolder->FindObject("Hits") ;
 396   if(!h) {
 397     cerr << "ERROR: AliPHOSGetter::HitsRef -> " << phosFolder->GetName() << "/Hits not found !" << endl ;
 398     abort() ;
 399   }
 400   else
 401     return phosFolder->GetListOfFolders()->GetObjectRef(h) ;
 402 }
 403
 404 //____________________________________________________________________________
 405 Bool_t AliPHOSGetter::PostSDigits(const char * name, const char * headerFile) const
 406 {  //---------- SDigits -------------------------
 407
 408
 409   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/SDigits/headerFile/sdigitsname
 410   // because you can have sdigits from several hit files for mixing
 411
 412   TFolder * phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
 413   if ( !phosFolder ) {
 414     if (fDebug) {
 415       cout << "WARNING: AliPHOSGetter::Post S -> Folder //" << fSDigitsFolder << "/PHOS/ not found!" << endl;
 416       cout << "INFO:    AliPHOSGetter::Post S -> Adding Folder //" << fHitsFolder << "/PHOS/" << endl;
 417     }
 418     phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ;
 419   }
 420   TString subdir(headerFile) ;
 421   subdir.ReplaceAll("/","_") ;
 422   TFolder * phosSubFolder = dynamic_cast<TFolder*>(phosFolder->FindObject(subdir)) ;
 423   if ( !phosSubFolder )
 424     phosSubFolder = phosFolder->AddFolder(subdir, "");
 425
 426   TObject * sd  = phosSubFolder->FindObject(name);
 427   if ( sd ) {
 428     if (fDebug)
 429       cerr <<"INFO: AliPHOSGetter::Post S -> Folder " << subdir
 430            << " already exists!" << endl ;
 431   }else{
 432     TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1) ;
 433     sdigits->SetName(name) ;
 434     phosSubFolder->Add(sdigits) ;
 435   }
 436
 437   return kTRUE;
 438 }
 439 //____________________________________________________________________________
 440 TObject** AliPHOSGetter::SDigitsRef(const char * name, const char * file) const
 441 {  //------- SDigits ----------------------
 442
 443   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/SDigits/filename/SDigits
 444
 445   if ( !fSDigitsFolder ) {
 446     cerr << "ERROR: AliPHOSGetter::SDigitsRef -> Folder //" << fSDigitsFolder << " not found!" << endl;
 447     abort() ;
 448   }
 449
 450   TFolder * phosFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
 451   if ( !phosFolder ) {
 452     cerr << "ERROR: AliPHOSGetter::SDigitsRef -> Folder //" << fSDigitsFolder << "/PHOS/ not found!" << endl;
 453     abort() ;
 454   }
 455
 456   TFolder * phosSubFolder = 0 ;
 457   if(file)
 458     phosSubFolder = dynamic_cast<TFolder *>(phosFolder->FindObject(file)) ;
 459   else
 460     phosSubFolder = dynamic_cast<TFolder *>(phosFolder->FindObject(fHeaderFile)) ;
 461
 462   if(!phosSubFolder) {
 463     cerr << "ERROR: AliPHOSGetter::DigitesSRef -> Folder //Folders/RunMC/Event/Data/PHOS/" << file << "not found!" << endl;
 464     abort() ;
 465   }
 466
 467   TObject * dis = phosSubFolder->FindObject(name) ;
 468   if(!dis){
 469     cerr << "ERROR: AliPHOSGetter::DigitesSRef -> object " << name << " not found! " << endl ;
 470     abort()  ;
 471   }
 472   else
 473     return phosSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
 474
 475 }
 476
 477 //____________________________________________________________________________
 478 Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const
 479 {  //---------- SDigitizer -------------------------
 480
 481   // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
 482
 483
 484   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 485
 486   if ( !sd ) {
 487     cerr << "ERROR: AliPHOSGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 488     return kFALSE ;
 489   }
 490   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ;
 491   if ( !phos )  {
 492     if (fDebug) {
 493       cout <<"WARNING: AliPHOSGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/PHOS/ not found!" << endl;
 494       cout <<"INFO: AliPHOSGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/PHOS/" << endl;
 495     }
 496     phos = new TTask("PHOS", "") ;
 497     sd->Add(phos) ;
 498   }
 499   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdigitizer->GetName() ));
 500   if (phossd) {
 501     if (fDebug)
 502       cout << "INFO: AliPHOSGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ;
 503     phos->GetListOfTasks()->Remove(phossd) ;
 504   }
 505   phos->Add(sdigitizer) ;
 506   return kTRUE;
 507
 508 }
 509
 510 //____________________________________________________________________________
 511 TObject** AliPHOSGetter::SDigitizerRef(const char * name) const
 512 {
 513
 514   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 515   if ( !sd ) {
 516     cerr << "ERROR: AliPHOSGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 517     abort();
 518   }
 519
 520   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ;
 521   if ( !phos )  {
 522     cerr <<"ERROR: AliPHOSGetter::Post SerRef ->  //" << fTasksFolder << "/SDigitizer/PHOS not found!" << endl;
 523     abort();
 524   }
 525
 526   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ;
 527
 528   return phos->GetListOfTasks()->GetObjectRef(task) ;
 529
 530 }
 531
 532 //____________________________________________________________________________
 533 Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const
 534 {  //---------- SDigitizer -------------------------
 535
 536  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
 537
 538   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 539   if ( !sd ) {
 540     cerr << "ERROR: AliPHOSGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 541     return kFALSE ;
 542   }
 543
 544   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ;
 545   if ( !phos )  {
 546     if (fDebug) {
 547       cout <<"WARNING: AliPHOSGetter::Post Ser ->  //" << fTasksFolder << "/SDigitizer/PHOS/ not found!" << endl;
 548       cout <<"INFO: AliPHOSGetter::Post Ser -> Adding  //" << fTasksFolder << "/SDigitizer/PHOS" << endl;
 549     }
 550     phos = new TTask("PHOS", "") ;
 551     sd->Add(phos) ;
 552   }
 553
 554   TString sdname(name) ;
 555   sdname.Append(":") ;
 556   sdname.Append(file);
 557   sdname.ReplaceAll("/","_") ;
 558   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdname ));
 559   if (!phossd) {
 560     phossd = new AliPHOSSDigitizer() ;
 561     //Note, we can not call constructor with parameters: it will call Getter and scew up everething
 562     phossd->SetName(sdname) ;
 563     phossd->SetTitle(file) ;
 564     phos->Add(phossd) ;
 565   }
 566   return kTRUE;
 567
 568 }
 569
 570 //____________________________________________________________________________
 571 Bool_t AliPHOSGetter::PostDigits(const char * name) const
 572 {  //---------- Digits -------------------------
 573
 574   // the hierarchy is //Folders/Run/Event/Data/PHOS/SDigits/name
 575
 576   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
 577
 578   if ( !phosFolder ) {
 579     if (fDebug) {
 580       cout << "WARNING: AliPHOSGetter::Post D -> Folder //" << fDigitsFolder << "/PHOS/ not found!" << endl;
 581       cout << "INFO:    AliPHOSGetter::Post D -> Adding Folder //" << fDigitsFolder << "/PHOS/" << endl;
 582     }
 583     phosFolder = fDigitsFolder->AddFolder("PHOS", "Digits from PHOS") ;
 584   }
 585
 586   TObject*  dig = phosFolder->FindObject( name ) ;
 587   if ( !dig ) {
 588     TClonesArray * digits = new TClonesArray("AliPHOSDigit",1000) ;
 589     digits->SetName(name) ;
 590     phosFolder->Add(digits) ;
 591   }
 592   return kTRUE;
 593 }
 594
 595 //____________________________________________________________________________
 596 TObject** AliPHOSGetter::DigitsRef(const char * name) const
 597 { //------- Digits ----------------------
 598
 599   // the hierarchy is //Folders/Run/Event/Data/PHOS/Digits/name
 600
 601   if ( !fDigitsFolder ) {
 602     cerr << "ERROR: AliPHOSGetter::DigitsRef -> Folder //" << fDigitsFolder << " not found!" << endl;
 603     abort() ;
 604   }
 605
 606   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
 607   if ( !phosFolder ) {
 608     cerr << "ERROR: AliPHOSGetter::DigitsRef -> Folder //" << fDigitsFolder << "/PHOS/ not found!" << endl;
 609     abort() ;
 610   }
 611
 612   TObject * d = phosFolder->FindObject(name) ;
 613   if(!d) {
 614     cerr << "ERROR: AliPHOSGetter::DigitsRef -> object " << name << " not found! " << endl ;
 615     abort() ;
 616   }
 617   else
 618     return phosFolder->GetListOfFolders()->GetObjectRef(d) ;
 619
 620 }
 621
 622 //____________________________________________________________________________
 623 Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const
 624 {  //---------- Digitizer -------------------------
 625
 626   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 627
 628   if ( !sd ) {
 629     cerr << "ERROR: AliPHOSGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 630     return kFALSE ;
 631   }
 632   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ;
 633   if ( !phos )  {
 634     if (fDebug) {
 635       cout <<"WARNING: AliPHOSGetter::Post Der ->  //" << fTasksFolder << "/Digitizer/PHOS not found!" << endl;
 636       cout <<"INFO: AliPHOSGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/PHOS" << endl;
 637     }
 638     phos = new TTask("PHOS", "") ;
 639     sd->Add(phos) ;
 640   }
 641
 642     AliPHOSDigitizer * phosd = dynamic_cast<AliPHOSDigitizer*>(phos->GetListOfTasks()->FindObject(digitizer->GetName())) ;
 643     if (phosd) {
 644       phosd->Delete() ;
 645       phos->GetListOfTasks()->Remove(phosd) ;
 646     }
 647     phos->Add(digitizer) ;
 648     return kTRUE;
 649 }
 650
 651 //____________________________________________________________________________
 652 Bool_t AliPHOSGetter::PostDigitizer(const char * name) const
 653 {  //---------- Digitizer -------------------------
 654
 655  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
 656
 657   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 658   if ( !d ) {
 659     cerr << "ERROR: AliPHOSGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 660     return kFALSE ;
 661   }
 662
 663   TTask * phos = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("PHOS")) ;
 664   if ( !phos )  {
 665     if (fDebug) {
 666       cout <<"WARNING: AliPHOSGetter::Post Der -> //" << fTasksFolder << "/Digitizer/PHOS not found!" << endl;
 667       cout <<"INFO: AliPHOSGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/PHOS" << endl;
 668     }
 669     phos = new TTask("PHOS", "") ;
 670     d->Add(phos) ;
 671 }
 672
 673   AliPHOSDigitizer * phosd = dynamic_cast<AliPHOSDigitizer*>(phos->GetListOfTasks()->FindObject(name)) ;
 674   if (!phosd) {
 675     phosd = new AliPHOSDigitizer() ;
 676     phosd->SetName(fDigitsTitle) ;
 677     phosd->SetTitle(fHeaderFile) ;
 678     phos->Add(phosd) ;
 679   }
 680   return kTRUE;
 681 }
 682
 683 //____________________________________________________________________________
 684 TObject** AliPHOSGetter::DigitizerRef(const char * name) const
 685 {
 686   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 687   if ( !sd ) {
 688     cerr << "ERROR: AliPHOSGetter::Post DerRef -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 689     abort();
 690   }
 691
 692   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ;
 693   if ( !phos )  {
 694     cerr <<"ERROR: AliPHOSGetter::Post DerRef ->  //" << fTasksFolder << "/Digitizer/PHOS" << endl;
 695     abort();
 696   }
 697
 698   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ;
 699
 700   return phos->GetListOfTasks()->GetObjectRef(task) ;
 701
 702 }
 703
 704 //____________________________________________________________________________
 705 Bool_t AliPHOSGetter::PostRecPoints(const char * name) const
 706 { // -------------- RecPoints -------------------------------------------
 707
 708   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
 709   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
 710
 711   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ;
 712
 713   if ( !phosFolder ) {
 714     if (fDebug) {
 715       cout << "WARNING: AliPHOSGetter::Post RPo -> Folder //" << fRecoFolder->GetName() << "/PHOS/ not found!" << endl;
 716       cout << "INFO:    AliPHOSGetter::Post Rpo -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/" << endl;
 717     }
 718     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;
 719   }
 720
 721   // EMCA RecPoints
 722   TFolder * phosRPoEMCAFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("EMCARecPoints")) ;
 723   if ( !phosRPoEMCAFolder ) {
 724     if (fDebug) {
 725       cout << "WARNING: AliPHOSGetter::Post RPo -> Folder //" << fRecoFolder->GetName() << "/PHOS/EMCARecPoints/ not found!" << endl;
 726       cout << "INFO:    AliPHOSGetter::Post Rpo -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/EMCARecPoints" << endl;
 727     }
 728     phosRPoEMCAFolder = phosFolder->AddFolder("EMCARecPoints", "EMCA RecPoints from PHOS") ;
 729   }
 730
 731   TObject * erp = phosFolder->FindObject( name ) ;
 732   if ( !erp )   {
 733     TObjArray * emcrp = new TObjArray(100) ;
 734     emcrp->SetName(name) ;
 735     phosRPoEMCAFolder->Add(emcrp) ;
 736   }
 737
 738   // CPV RecPoints
 739   TFolder * phosRPoCPVFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("CPVRecPoints")) ;
 740   if ( !phosRPoCPVFolder ) {
 741     if (fDebug) {
 742       cout << "WARNING: AliPHOSGetter::Post RPo -> Folder //" << fRecoFolder->GetName() << "/PHOS/CPVRecPoints/ not found!" << endl;
 743       cout << "INFO:    AliPHOSGetter::Post Rpo -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/CPVRecPoints/" << endl;
 744     }
 745     phosRPoCPVFolder = phosFolder->AddFolder("CPVRecPoints", "CPV RecPoints from PHOS") ;
 746   }
 747
 748   TObject * crp =  phosRPoCPVFolder->FindObject( name ) ;
 749   if ( !crp )   {
 750     TObjArray * cpvrp = new TObjArray(100) ;
 751     cpvrp->SetName(name) ;
 752     phosRPoCPVFolder->Add(cpvrp) ;
 753   }
 754   return kTRUE;
 755 }
 756
 757 //____________________________________________________________________________
 758 TObject** AliPHOSGetter::EmcRecPointsRef(const char * name) const
 759 { // -------------- RecPoints -------------------------------------------
 760
 761   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
 762
 763   if ( !fRecoFolder ) {
 764     cerr << "ERROR: AliPHOSGetter::EmcRecPointsRef -> Folder //" << fRecoFolder->GetName() << " not found!" << endl;
 765     abort() ;
 766   }
 767
 768   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
 769   if ( !phosFolder ) {
 770     cerr << "ERROR: AliPHOSGetter::EmcRecPointsRef -> Folder //" << fRecoFolder->GetName() << "/PHOS/EMCARecPoints/ not found!" << endl;
 771     abort() ;
 772   }
 773
 774
 775   TObject * erp = phosFolder->FindObject(name ) ;
 776   if ( !erp )   {
 777     cerr << "ERROR: AliPHOSGetter::EmcRecPointsRef -> object " << name << " not found! " << endl ;
 778     abort() ;
 779   }
 780   return phosFolder->GetListOfFolders()->GetObjectRef(erp) ;
 781
 782 }
 783
 784 //____________________________________________________________________________
 785 TObject** AliPHOSGetter::CpvRecPointsRef(const char * name) const
 786 { // -------------- RecPoints -------------------------------------------
 787
 788   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
 789
 790   if ( !fRecoFolder ) {
 791     cerr << "ERROR: AliPHOSGetter::CpvRecPointsRef -> Folder //" << fRecoFolder->GetName() << " not found!" << endl;
 792     abort() ;
 793   }
 794
 795   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
 796   if ( !phosFolder ) {
 797     cerr << "ERROR: AliPHOSGetter::CpvRecPointsRef -> Folder //" << fRecoFolder->GetName() << "/PHOS/CPVRecPoints/" << endl;
 798     abort() ;
 799   }
 800
 801   TObject * crp = phosFolder->FindObject(name ) ;
 802   if ( !crp )   {
 803     cerr << "ERROR: AliPHOSGetter::CpvRecPointsRef -> object " << name << " not found " << endl ;
 804     abort() ;
 805   }
 806   return phosFolder->GetListOfFolders()->GetObjectRef(crp) ;
 807
 808 }
 809
 810 //____________________________________________________________________________
 811 Bool_t AliPHOSGetter::PostClusterizer(AliPHOSClusterizer * clu) const
 812 { // ------------------ AliPHOSClusterizer ------------------------
 813
 814   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
 815
 816   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
 817
 818   if ( !tasks ) {
 819     cerr << "ERROR: AliPHOSGetter::Post Rer -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
 820     return kFALSE ;
 821   }
 822
 823   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
 824   if ( !phos )  {
 825     if (fDebug) {
 826       cout <<"WARNING: AliPHOSGetter::Post Rer -> //" << fTasksFolder << "/ReconstructionerPHOS not found!" << endl;
 827       cout <<"INFO: AliPHOSGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
 828     }
 829     phos = new TTask("PHOS", "") ;
 830     tasks->Add(phos) ;
 831   }
 832
 833   AliPHOSClusterizer * phoscl = dynamic_cast<AliPHOSClusterizer*>(phos->GetListOfTasks()->FindObject(clu->GetName())) ;
 834   if (phoscl) {
 835     if (fDebug)
 836       cout << "INFO: AliPHOSGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ;
 837     phoscl->Delete() ;
 838     phos->GetListOfTasks()->Remove(phoscl) ;
 839   }
 840   phos->Add(clu) ;
 841   return kTRUE;
 842 }
 843
 844 //____________________________________________________________________________
 845 TObject** AliPHOSGetter::ClusterizerRef(const char * name) const
 846 { // ------------------ AliPHOSClusterizer ------------------------
 847
 848   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
 849
 850   if ( !tasks ) {
 851     cerr << "ERROR: AliPHOSGetter::ClusterizerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
 852     abort() ;
 853   }
 854
 855   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
 856   if ( !phos )  {
 857     cerr <<"WARNING: AliPHOSGetter::ClusterizerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/PHOS" << endl;
 858     abort() ;
 859   }
 860
 861   TList * l = phos->GetListOfTasks() ;
 862   TIter it(l) ;
 863   TTask * task ;
 864   TTask * clu = 0 ;
 865   TString cluname(name) ;
 866   cluname+=":clu" ;
 867   while((task = static_cast<TTask *>(it.Next()) )){
 868     TString taskname(task->GetName()) ;
 869     if(taskname.BeginsWith(cluname)){
 870       clu = task ;
 871       break ;
 872     }
 873   }
 874
 875   if(clu)
 876     return l->GetObjectRef(clu) ;
 877   else{
 878     cerr << "ERROR: AliPHOSGetter::ClusterizerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner/clusterizer " <<  name << " not found!" << endl;
 879     abort() ;
 880   }
 881 }
 882
 883 //____________________________________________________________________________
 884 Bool_t AliPHOSGetter::PostClusterizer(const char * name) const
 885 { // ------------------ AliPHOSClusterizer ------------------------
 886
 887   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
 888
 889   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
 890
 891   if ( !tasks ) {
 892     cerr << "ERROR: AliPHOSGetter::Post Rer -> Task//" << fTasksFolder << "/Reconstructioner not found!" << endl;
 893     return kFALSE ;
 894   }
 895
 896   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
 897   if ( !phos )  {
 898     if (fDebug) {
 899       cout <<"WARNING: AliPHOSGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
 900       cout <<"INFO: AliPHOSGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
 901     }
 902     phos = new TTask("PHOS", "") ;
 903     tasks->Add(phos) ;
 904   }
 905
 906   TList * l = phos->GetListOfTasks() ;
 907   TIter it(l) ;
 908   TString clun(name) ;
 909   clun+=":clu" ;
 910   TTask * task ;
 911   while((task = static_cast<TTask *>(it.Next()) )){
 912     TString taskname(task->GetName()) ;
 913     if(taskname.BeginsWith(clun))
 914       return kTRUE ;
 915   }
 916
 917   AliPHOSClusterizerv1 * phoscl = new AliPHOSClusterizerv1() ;
 918   phoscl->SetName(clun) ;
 919   phos->Add(phoscl) ;
 920   return kTRUE;
 921
 922 }
 923
 924 //____________________________________________________________________________
 925 Bool_t AliPHOSGetter::PostTrackSegments(const char * name) const
 926 { // ---------------TrackSegments -----------------------------------
 927
 928   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
 929
 930   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ;
 931
 932   if ( !phosFolder ) {
 933     if (fDebug) {
 934       cout << "WARNING: AliPHOSGetter::Post TS -> Folder //" << fRecoFolder << "/PHOS/ not found!" << endl;
 935       cout << "INFO:    AliPHOSGetter::Post TS -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS" << endl;
 936     }
 937     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;
 938   }
 939
 940   TFolder * phosTSFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("TrackSegments")) ;
 941   if ( !phosTSFolder ) {
 942     if (fDebug) {
 943       cout << "WARNING: AliPHOSGetter::Post TS -> Folder//" << fRecoFolder->GetName() << "/PHOS/TrackSegments/ not found!" << endl;
 944       cout << "INFO:    AliPHOSGetter::Post TS -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/TrackSegments/" << endl;
 945     }
 946     phosTSFolder = phosFolder->AddFolder("TrackSegments", "TrackSegments from PHOS") ;
 947   }
 948
 949   TObject * tss =  phosTSFolder->FindObject( name ) ;
 950   if (!tss) {
 951     TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
 952     ts->SetName(name) ;
 953     phosTSFolder->Add(ts) ;
 954   }
 955   return kTRUE;
 956 }
 957
 958 //____________________________________________________________________________
 959 TObject** AliPHOSGetter::TrackSegmentsRef(const char * name) const
 960 { // ---------------TrackSegments -----------------------------------
 961
 962   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
 963
 964  if ( !fRecoFolder ) {
 965     cerr << "ERROR: AliPHOSGetter::TrackSegmentsRef -> Folder //" << fRecoFolder->GetName() << "not found!" << endl;
 966     abort() ;
 967   }
 968
 969   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
 970   if ( !phosFolder ) {
 971     cerr << "ERROR: AliPHOSGetter::TrackSegmentsRef -> Folder //" << fRecoFolder->GetName() << "/PHOS/TrackSegments/ not found!" << endl;
 972     abort() ;
 973   }
 974
 975   TObject * tss =  phosFolder->FindObject(name) ;
 976   if (!tss) {
 977     cerr << "ERROR: AliPHOSGetter::TrackSegmentsRef -> object " << name << " not found! " << endl ;
 978     abort() ;
 979   }
 980   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
 981 }
 982
 983 //____________________________________________________________________________
 984 Bool_t AliPHOSGetter::PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tsmaker) const
 985 { //------------Track Segment Maker ------------------------------
 986
 987   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
 988
 989   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
 990
 991   if ( !tasks ) {
 992     cerr << "ERROR: AliPHOSGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
 993     return kFALSE ;
 994   }
 995
 996   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
 997   if ( !phos )  {
 998     if (fDebug) {
 999       cout <<"WARNING: AliPHOSGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1000       cout <<"INFO: AliPHOSGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
1001     }
1002     phos = new TTask("PHOS", "") ;
1003     tasks->Add(phos) ;
1004   }
1005
1006   AliPHOSTrackSegmentMaker * phosts =
1007     dynamic_cast<AliPHOSTrackSegmentMaker*>(phos->GetListOfTasks()->FindObject(tsmaker->GetName())) ;
1008   if (phosts) {
1009     phosts->Delete() ;
1010     phos->GetListOfTasks()->Remove(phosts) ;
1011   }
1012   phos->Add(tsmaker) ;
1013   return kTRUE;
1014
1015 }
1016 //____________________________________________________________________________
1017 Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const
1018 { //------------Track Segment Maker ------------------------------
1019
1020   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1021
1022
1023   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1024
1025   if ( !tasks ) {
1026     cerr << "ERROR: AliPHOSGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1027     return kFALSE ;
1028   }
1029
1030   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1031   if ( !phos )  {
1032     if (fDebug) {
1033       cout <<"WARNING: AliPHOSGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1034       cout <<"INFO: AliPHOSGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
1035     }
1036     phos = new TTask("PHOS", "") ;
1037     tasks->Add(phos) ;
1038   }
1039
1040   TList * l = phos->GetListOfTasks() ;
1041   TIter it(l) ;
1042   TString tsn(name);
1043   tsn+=":tsm" ;
1044   TTask * task ;
1045   while((task = static_cast<TTask *>(it.Next()) )){
1046     TString taskname(task->GetName()) ;
1047     if(taskname.BeginsWith(tsn))
1048       return kTRUE ;
1049   }
1050
1051   AliPHOSTrackSegmentMakerv1 * phosts = new AliPHOSTrackSegmentMakerv1() ;
1052   phosts->SetName(tsn) ;
1053
1054   phos->Add(phosts) ;
1055   return kTRUE;
1056
1057 }
1058
1059 //____________________________________________________________________________
1060 TObject** AliPHOSGetter::TSMakerRef(const char * name) const
1061 { //------------Track Segment Maker ------------------------------
1062
1063   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1064
1065   if ( !tasks ) {
1066     cerr << "ERROR: AliPHOSGetter::TSMakerRef -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1067     abort() ;
1068   }
1069
1070   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1071   if ( !phos )  {
1072     cerr <<"WARNING: AliPHOSGetter::TSMakerRef -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1073     abort()  ;
1074   }
1075
1076   TList * l = phos->GetListOfTasks() ;
1077   TIter it(l) ;
1078   TTask * task ;
1079   TTask * tsm = 0 ;
1080   TString tsmname(name) ;
1081   tsmname+=":tsm" ;
1082   while((task = static_cast<TTask *>(it.Next()) )){
1083     TString taskname(task->GetName()) ;
1084     if(taskname.BeginsWith(tsmname)){
1085       tsm = task ;
1086       break ;
1087     }
1088   }
1089
1090   if(tsm)
1091     return l->GetObjectRef(tsm) ;
1092   else {
1093     cerr << "ERROR: AliPHOSGetter::TSMakerRef -> Task //" << fTasksFolder << "/Reconstructioner/TrackSegmentMarker name not found!" << endl;
1094     abort() ;
1095   }
1096 }
1097
1098 //____________________________________________________________________________
1099 Bool_t AliPHOSGetter::PostRecParticles(const char * name) const
1100 {  // -------------------- RecParticles ------------------------
1101
1102   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1103
1104   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ;
1105
1106   if ( !phosFolder ) {
1107     if (fDebug) {
1108       cout << "WARNING: AliPHOSGetter::Post RPa -> Folder //" << fRecoFolder->GetName() << "/PHOS/ not found!" << endl;
1109       cout << "INFO:    AliPHOSGetter::Post Rpa -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/" << endl;
1110     }
1111     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;
1112   }
1113
1114  TFolder * phosRPaFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("RecParticles")) ;
1115   if ( !phosRPaFolder ) {
1116     if (fDebug) {
1117       cout << "WARNING: AliPHOSGetter::Post RPa -> Folder //" << fRecoFolder->GetName() << "/PHOS/RecParticles/ not found!" << endl;
1118       cout << "INFO:    AliPHOSGetter::Post RPa -> Adding Folder //" << fRecoFolder->GetName() << "/PHOS/RecParticles/" << endl;
1119     }
1120     phosRPaFolder = phosFolder->AddFolder("RecParticles", "RecParticles from PHOS") ;
1121   }
1122
1123   TObject * rps = phosRPaFolder->FindObject( name )  ;
1124   if ( !rps ) {
1125     TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
1126     rp->SetName(name) ;
1127     phosRPaFolder->Add(rp) ;
1128   }
1129   return kTRUE;
1130 }
1131
1132 //____________________________________________________________________________
1133 TObject** AliPHOSGetter::RecParticlesRef(const char * name) const
1134 { // ---------------TrackSegments -----------------------------------
1135
1136   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1137
1138  if ( !fRecoFolder ) {
1139     cerr << "ERROR: AliPHOSGetter::RecParticlesRef -> Folder//" << fRecoFolder->GetName() << " not found!" << endl;
1140     abort() ;
1141   }
1142
1143   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
1144   if ( !phosFolder ) {
1145     cerr << "ERROR: AliPHOSGetter::RecParticlesRef -> Folder //" << fRecoFolder->GetName() << "/PHOS/RecParticles/ not found!" << endl;
1146     abort() ;
1147   }
1148
1149   TObject * tss =  phosFolder->FindObject(name  ) ;
1150   if (!tss) {
1151     cerr << "ERROR: AliPHOSGetter::RecParticlesRef -> object " << name << " not found! " << endl ;
1152     abort() ;
1153   }
1154   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
1155 }
1156
1157 //____________________________________________________________________________
1158 Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const
1159 {      // ------------AliPHOS PID -----------------------------
1160
1161   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1162
1163   if ( !tasks ) {
1164     cerr << "ERROR: AliPHOSGetter::Post Per -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1165     return kFALSE ;
1166   }
1167
1168   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1169   if ( !phos )  {
1170     if (fDebug) {
1171       cout <<"WARNING: AliPHOSGetter::Post Per -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1172       cout <<"INFO: AliPHOSGetter::Post Per -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
1173     }
1174     phos = new TTask("PHOS", "") ;
1175     tasks->Add(phos) ;
1176   }
1177
1178   AliPHOSPID * phospid = dynamic_cast<AliPHOSPID*>(phos->GetListOfTasks()->FindObject(pid->GetName())) ;
1179   if (phospid) {
1180     if (fDebug)
1181       cout << "INFO: AliPHOSGetter::Post Per -> Task " << pid->GetName()
1182            << " already exists" << endl ;
1183     phos->GetListOfTasks()->Remove(phospid) ;
1184   }
1185
1186   phos->Add(pid) ;
1187   return kTRUE;
1188 }
1189
1190 //____________________________________________________________________________
1191 Bool_t AliPHOSGetter::PostPID(const char * name) const
1192 {
1193   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1194
1195   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1196
1197   if ( !tasks ) {
1198     cerr << "ERROR: AliPHOSGetter::Post Per -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1199     return kFALSE ;
1200   }
1201
1202   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1203   if ( !phos )  {
1204     if (fDebug) {
1205       cout <<"WARNING: AliPHOSGetter::Post Per -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1206       cout <<"INFO: AliPHOSGetter::Post Per -> Adding //" << fTasksFolder << "/Reconstructioner/PHOS" << endl;
1207     }
1208     phos = new TTask("PHOS", "") ;
1209     tasks->Add(phos) ;
1210   }
1211
1212   TList * l = phos->GetListOfTasks() ;
1213   TIter it(l) ;
1214   TString pidname(name) ;
1215   pidname+=":pidv1" ;
1216   TTask * task ;
1217   while((task = static_cast<TTask *>(it.Next()) )){
1218     TString taskname(task->GetName()) ;
1219     if(taskname.BeginsWith(pidname))
1220       return kTRUE ;
1221   }
1222
1223   AliPHOSPIDv1 * phospid = new AliPHOSPIDv1() ;
1224   phospid->SetName(pidname) ;
1225   phos->Add(phospid) ;
1226
1227   return kTRUE;
1228 }
1229
1230 //____________________________________________________________________________
1231 TObject** AliPHOSGetter::PIDRef(const char * name) const
1232 { //------------PID ------------------------------
1233
1234   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1235
1236   if ( !tasks ) {
1237     cerr << "ERROR: AliPHOSGetter::PIDRef -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1238     abort() ;
1239   }
1240
1241   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1242   if ( !phos )  {
1243     cerr << "ERROR: AliPHOSGetter::PIDRef -> //" << fTasksFolder << "/Reconstructioner/PHOS not found!" << endl;
1244     abort()  ;
1245   }
1246
1247   TList * l = phos->GetListOfTasks() ;
1248   TIter it(l) ;
1249   TTask * task ;
1250   TTask * pid = 0 ;
1251   TString pidname(name) ;
1252   pidname+=":pid" ;
1253   while((task = static_cast<TTask *>(it.Next()) )){
1254     TString taskname(task->GetName()) ;
1255     if(taskname.BeginsWith(pidname)){
1256       pid = task ;
1257       break ;
1258     }
1259   }
1260
1261   if(pid)
1262     return l->GetObjectRef(pid) ;
1263   else {
1264     cerr << "ERROR: AliPHOSGetter::PIDRef -> Task //" << fTasksFolder << "/Reconstructioner/PID name not found!" << endl;
1265     abort() ;
1266   }
1267
1268 }
1269
1270 //____________________________________________________________________________
1271 Bool_t AliPHOSGetter::PostQA(void) const
1272 { // ------------------ QA ---------------------------------
1273
1274   // the hierarchy is //Folders/Run/Conditions/QA/PHOS/alarmsName
1275
1276   TFolder * phosFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("PHOS")) ;
1277   if ( !phosFolder ) {
1278     if (fDebug) {
1279       cout << "WARNING: AliPHOSGetter::Post Q -> Folder //" << fQAFolder << "/PHOS/ not found!" << endl;
1280       cout << "INFO:    AliPHOSGetter::Post Q -> Adding Folder //" << fQAFolder << "/PHOS/" << endl;
1281     }
1282     phosFolder = fQAFolder->AddFolder("PHOS", "QA from PHOS") ;
1283   }
1284
1285   return kTRUE;
1286 }
1287
1288 //____________________________________________________________________________
1289 TObject** AliPHOSGetter::AlarmsRef(void) const
1290 {  //------- Alarms ----------------------
1291
1292
1293   // the hierarchy is //Folders/Run/Conditions/QA/PHOS
1294   if ( !fQAFolder ) {
1295     cerr << "ERROR: AliPHOSGetter::AlarmsRef -> Folder //" << fQAFolder << " not found!" << endl;
1296     abort() ;
1297   }
1298
1299   TFolder * phosFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ;
1300   if ( !phosFolder ) {
1301     cerr << "ERROR: AliPHOSGetter::AlarmsRef -> Folder //" << fQAFolder << "/PHOS/ not found!" << endl;
1302     abort() ;
1303   }
1304
1305   return fQAFolder->GetListOfFolders()->GetObjectRef(phosFolder) ;
1306 }
1307
1308 //____________________________________________________________________________
1309 const TParticle * AliPHOSGetter::Primary(Int_t index) const
1310 {
1311   // Return primary particle numbered by <index>
1312
1313   if(index < 0)
1314     return 0 ;
1315   TParticle *  p = gAlice->Particle(index) ;
1316 //   if (p->GetFirstMother() != -1 ) {
1317 //     cout << "AliPHOSGetter::Primary : Not a primary " << endl ;
1318 //   }
1319   return p ;
1320
1321
1322 //   Int_t primaryIndex = index % 10000000 ;
1323 //   Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.)  ;
1324
1325 //   if ( primaryList > 0  ) {
1326 //     if (fDebug) {
1327 //       cout << " Getter does not support currently Mixing of primary " << endl ;
1328 //       cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
1329 //     }
1330 //     return 0;
1331 //   }
1332
1333 //   return gAlice->Particle(primaryIndex) ;
1334
1335 }
1336
1337 //____________________________________________________________________________
1338 const TParticle * AliPHOSGetter::Secondary(TParticle* p, Int_t index) const
1339 {
1340   // Return first (index=1) or second (index=2) secondary particle of primary particle p
1341
1342   if(index <= 0)
1343     return 0 ;
1344   if(index > 2)
1345     return 0 ;
1346
1347   if(p) {
1348   Int_t daughterIndex = p->GetDaughter(index-1) ;
1349   return  gAlice->Particle(daughterIndex) ;
1350   }
1351   else
1352     return 0 ;
1353 }
1354
1355 //____________________________________________________________________________
1356 Int_t AliPHOSGetter::ReadTreeD()
1357 {
1358   // Read the digit tree gAlice->TreeD()
1359   if(gAlice->TreeD()== 0){
1360     cerr <<   "WARNING: AliPHOSGetter::ReadTreeD: can not read TreeD " << endl ;
1361   return 1;
1362   }
1363
1364   TObjArray * lob = static_cast<TObjArray*>(gAlice->TreeD()->GetListOfBranches()) ;
1365   TIter next(lob) ;
1366   TBranch * branch = 0 ;
1367   TBranch * digitsbranch = 0 ;
1368   TBranch * digitizerbranch = 0 ;
1369   Bool_t phosfound = kFALSE, digitizerfound = kFALSE ;
1370
1371   while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !digitizerfound) ) {
1372     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1373       digitsbranch = branch ;
1374       phosfound = kTRUE ;
1375     }
1376     else if ( (strcmp(branch->GetName(), "AliPHOSDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1377       digitizerbranch = branch ;
1378       digitizerfound = kTRUE ;
1379     }
1380   }
1381
1382   if ( !phosfound || !digitizerfound ) {
1383     if (fDebug)
1384       cout << "WARNING: AliPHOSGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name "
1385            << fDigitsTitle << endl ;
1386     return 2;
1387   }
1388
1389   //read digits
1390   if(!Digits(fDigitsTitle) )
1391     PostDigits(fDigitsTitle);
1392   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1393   digitsbranch->GetEntry(0) ;
1394
1395
1396   // read  the Digitizer
1397   if(!Digitizer(fDigitsTitle))
1398     PostDigitizer(fDigitsTitle) ;
1399   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1400   digitizerbranch->GetEntry(0) ;
1401
1402   return 0 ;
1403 }
1404
1405 //____________________________________________________________________________
1406 Int_t AliPHOSGetter::ReadTreeH()
1407 {
1408   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1409
1410   if(gAlice->TreeH()== 0){
1411     cerr <<   "WARNING: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
1412     return 1;
1413   }
1414
1415   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("PHOS")) ;
1416   if ( !hitsbranch ) {
1417     if (fDebug)
1418       cout << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ;
1419     return 2;
1420   }
1421   if(!Hits())
1422     PostHits() ;
1423
1424   if (hitsbranch->GetEntries() > 1 ) {
1425     TClonesArray * tempo =  new TClonesArray("AliPHOSHit",1000) ;
1426     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ;
1427     hitsbranch->SetAddress(&tempo) ;
1428     Int_t index = 0 ;
1429     Int_t i = 0 ;
1430     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
1431       hitsbranch->GetEntry(i) ;
1432       Int_t j = 0 ;
1433       for ( j = 0 ; j < tempo->GetEntries() ; j++) {
1434         const AliPHOSHit * hit = static_cast<const AliPHOSHit *>(tempo->At(j)) ;
1435         new((*hits)[index]) AliPHOSHit( *hit ) ;
1436         index++ ;
1437       }
1438     }
1439     delete tempo ;
1440   }
1441   else {
1442     hitsbranch->SetAddress(HitsRef()) ;
1443     hitsbranch->GetEntry(0) ;
1444   }
1445   return 0 ;
1446 }
1447
1448 //____________________________________________________________________________
1449 void AliPHOSGetter::Track(Int_t itrack)
1450 {
1451   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1452
1453   if(gAlice->TreeH()== 0){
1454     cerr <<   "ERROR: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
1455     return ;
1456   }
1457
1458   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS")) ;
1459   if ( !hitsbranch ) {
1460     if (fDebug)
1461       cout << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ;
1462     return ;
1463   }
1464   if(!Hits())
1465     PostHits() ;
1466
1467   hitsbranch->SetAddress(HitsRef()) ;
1468   hitsbranch->GetEntry(itrack) ;
1469
1470
1471 }
1472 //____________________________________________________________________________
1473 void AliPHOSGetter::ReadTreeQA()
1474 {
1475   // Read the digit tree gAlice->TreeQA()
1476   // so far only PHOS knows about this Tree
1477
1478   if(PHOS()->TreeQA()== 0){
1479     cerr <<   "ERROR: AliPHOSGetter::ReadTreeQA: can not read TreeQA " << endl ;
1480     return ;
1481   }
1482
1483   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ;
1484   if (!qabranch) {
1485     if (fDebug)
1486       cout << "WARNING: AliPHOSGetter::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
1487     return ;
1488   }
1489
1490   if(!Alarms())
1491     PostQA() ;
1492
1493   qabranch->SetAddress(AlarmsRef()) ;
1494
1495   qabranch->GetEntry(0) ;
1496
1497 //   PostQA("PHOS") ;
1498 //   TFolder * alarmsF = Alarms() ;
1499 //   alarmsF->Clear() ;
1500 //   qabranch->SetAddress(&alarmsF) ;
1501 //   qabranch->GetEntry(0) ;
1502
1503 }
1504
1505 //____________________________________________________________________________
1506 Int_t AliPHOSGetter::ReadTreeR(Bool_t any)
1507 {
1508   // Read the reconstrunction tree gAlice->TreeR()
1509   // A particularity has been introduced here :
1510   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
1511   //   being for example give in AliPHOSPID(fileName, title)
1512   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
1513   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
1514   // from a given set of TrackSegments (with a given name)
1515   // This is why any is NOT used to read the branch of RecParticles
1516   // any migh have become obsolete : to be checked
1517   // See AliPHOSPIDv1
1518
1519   if(gAlice->TreeR()== 0){
1520     cerr <<   "WARNING: AliPHOSGetter::ReadTreeR: can not read TreeR " << endl ;
1521     return 1;
1522   }
1523   // RecPoints
1524   TObjArray * lob = static_cast<TObjArray*>(gAlice->TreeR()->GetListOfBranches()) ;
1525   TIter next(lob) ;
1526   TBranch * branch = 0 ;
1527   TBranch * emcbranch = 0 ;
1528   TBranch * cpvbranch = 0 ;
1529   TBranch * clusterizerbranch = 0 ;
1530   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ;
1531
1532
1533   while ( (branch = static_cast<TBranch*>(next())) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) )
1534
1535     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 || any) {
1536       if ( strcmp(branch->GetName(), "PHOSEmcRP")==0) {
1537         emcbranch = branch ;
1538         phosemcrpfound = kTRUE ;
1539       }
1540       else if ( strcmp(branch->GetName(), "PHOSCpvRP")==0) {
1541         cpvbranch = branch ;
1542         phoscpvrpfound = kTRUE ;
1543       }
1544       else if(strcmp(branch->GetName(), "AliPHOSClusterizer")==0){
1545         clusterizerbranch = branch ;
1546         clusterizerfound = kTRUE ;
1547       }
1548     }
1549
1550   if ( !phosemcrpfound ) {
1551     if (fDebug)
1552       cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find EmcRecPoints with title "
1553            << fRecPointsTitle << endl ;
1554
1555   } else {
1556     if(!EmcRecPoints(fRecPointsTitle) )
1557       PostRecPoints(fRecPointsTitle) ;
1558     emcbranch->SetAddress(EmcRecPointsRef(fRecPointsTitle)) ;
1559     emcbranch->GetEntry(0) ;
1560   }
1561
1562   if ( !phoscpvrpfound ) {
1563     if (fDebug)
1564       cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find CpvRecPoints with title "
1565            << fRecPointsTitle << endl ;
1566   } else {
1567     cpvbranch->SetAddress(CpvRecPointsRef(fRecPointsTitle)) ;
1568     cpvbranch->GetEntry(0) ;
1569   }
1570
1571   if ( !clusterizerfound ) {
1572     if (fDebug)
1573       cout << "WARNING: AliPHOSGetter::ReadTreeR -> Can not find Clusterizer with title "
1574            << fRecPointsTitle << endl ;
1575   }  else {
1576     if(!Clusterizer(fRecPointsTitle) )
1577       PostClusterizer(fRecPointsTitle) ;
1578     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1579     clusterizerbranch->GetEntry(0) ;
1580   }
1581
1582   //------------------- TrackSegments ---------------------
1583   next.Reset() ;
1584   TBranch * tsbranch = 0 ;
1585   TBranch * tsmakerbranch = 0 ;
1586   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ;
1587
1588   while ( (branch = static_cast<TBranch*>(next())) && (!phostsfound || !tsmakerfound) )
1589     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0 || any)  {
1590       if ( strcmp(branch->GetName(), "PHOSTS")==0){
1591         tsbranch = branch ;
1592         phostsfound = kTRUE ;
1593       }
1594       else if(strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) {
1595         tsmakerbranch = branch ;
1596         tsmakerfound  = kTRUE ;
1597       }
1598     }
1599
1600   if ( !phostsfound || !tsmakerfound ) {
1601     if (fDebug)
1602       cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
1603            << fTrackSegmentsTitle << endl ;
1604   } else {
1605     // Read and Post the TrackSegments
1606     if(!TrackSegments(fTrackSegmentsTitle))
1607       PostTrackSegments(fTrackSegmentsTitle) ;
1608     tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
1609     tsbranch->GetEntry(0) ;
1610     // Read and Post the TrackSegment Maker
1611     if(!TrackSegmentMaker(fTrackSegmentsTitle))
1612       PostTrackSegmentMaker(fTrackSegmentsTitle) ;
1613     tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
1614     tsmakerbranch->GetEntry(0) ;
1615  }
1616
1617
1618   //------------ RecParticles ----------------------------
1619   next.Reset() ;
1620   TBranch * rpabranch = 0 ;
1621   TBranch * pidbranch = 0 ;
1622   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ;
1623
1624   while ( (branch = static_cast<TBranch*>(next())) && (!phosrpafound || !pidfound) )
1625     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {
1626       if ( strcmp(branch->GetName(), "PHOSRP")==0) {
1627         rpabranch = branch ;
1628         phosrpafound = kTRUE ;
1629       }
1630       else if (strcmp(branch->GetName(), "AliPHOSPID")==0) {
1631         pidbranch = branch ;
1632         pidfound  = kTRUE ;
1633       }
1634     }
1635
1636   if ( !phosrpafound || !pidfound ) {
1637     if (fDebug)
1638       cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name "
1639            << fRecParticlesTitle << endl ;
1640   } else {
1641     // Read and Post the RecParticles
1642     if(!RecParticles(fRecParticlesTitle))
1643       PostRecParticles(fRecParticlesTitle) ;
1644     rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
1645     rpabranch->GetEntry(0) ;
1646     // Read and Post the PID
1647     if(!PID(fRecParticlesTitle))
1648       PostPID(fRecParticlesTitle) ;
1649     pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
1650     pidbranch->GetEntry(0) ;
1651   }
1652   return 0 ;
1653 }
1654
1655 //____________________________________________________________________________
1656 Int_t AliPHOSGetter::ReadTreeS(Int_t event)
1657 {
1658   // Read the summable digits tree gAlice->TreeS()
1659
1660   // loop over all opened files and read their SDigits to the White Board
1661   TFolder * phosF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
1662   if (!phosF)
1663     phosF = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ;
1664   TCollection * folderslist = phosF->GetListOfFolders() ;
1665
1666   //Add current file to list if it is not there yet
1667
1668   TString subdir(fHeaderFile) ;
1669   subdir.ReplaceAll("/","_") ;
1670
1671   if ( (subdir != "aliroot") && ( !folderslist->Contains(subdir) ) ){
1672     phosF->AddFolder(subdir, "");
1673   }
1674
1675   TIter next(folderslist) ;
1676   TFolder * folder = 0 ;
1677   TFile * file;
1678   TTree * treeS = 0;
1679   while ( (folder = static_cast<TFolder*>(next())) ) {
1680     TString fileName(folder->GetName()) ;
1681     fileName.ReplaceAll("_","/") ;
1682     if(fHeaderFile.CompareTo(fileName) == 0 )
1683       treeS=gAlice->TreeS() ;
1684     else{
1685       file = static_cast<TFile*>(gROOT->GetFile(fileName));
1686       file->cd() ;
1687
1688       // Get SDigits Tree header from file
1689       TString treeName("TreeS") ;
1690       treeName += event ;
1691       treeS = dynamic_cast<TTree*>(gDirectory->Get(treeName.Data()));
1692     }
1693     if(treeS==0){
1694       cerr << "WARNING: AliPHOSGetter::ReadTreeS There is no SDigit Tree" << endl;
1695       return 1;
1696     }
1697
1698     //set address of the SDigits and SDigitizer
1699     TBranch   * sdigitsBranch    = 0;
1700     TBranch   * sdigitizerBranch = 0;
1701     TBranch   * branch           = 0 ;
1702     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
1703     TIter next(lob) ;
1704     Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ;
1705
1706     while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !sdigitizerfound) ) {
1707       if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1708         phosfound = kTRUE ;
1709         sdigitsBranch = branch ;
1710       }
1711
1712       else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1713         sdigitizerfound = kTRUE ;
1714         sdigitizerBranch = branch ;
1715       }
1716     }
1717     if ( !phosfound || !sdigitizerfound ) {
1718       if (fDebug)
1719         cout << "WARNING: AliPHOSDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName()
1720              << " not found" << endl ;
1721       return 2;
1722     }
1723
1724     if ( !folder->FindObject(fSDigitsTitle) )
1725       PostSDigits(fSDigitsTitle,folder->GetName()) ;
1726
1727     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
1728     sdigitsBranch->GetEntry(0) ;
1729
1730     TString sdname(fSDigitsTitle) ;
1731     sdname+=":" ;
1732     sdname+=folder->GetName() ;
1733     if(!SDigitizer(sdname) )
1734       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
1735
1736     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1737     sdigitizerBranch->GetEntry(0) ;
1738
1739   }
1740
1741   // After SDigits have been read from all files, return to the first one
1742
1743   next.Reset();
1744   folder = static_cast<TFolder*>(next());
1745   if(folder){
1746     TString fileName(folder->GetName()) ;
1747     fileName.ReplaceAll("_","/") ;
1748     file   = static_cast<TFile*>(gROOT->GetFile(fileName));
1749     file   ->cd() ;
1750   }
1751   return 0 ;
1752 }
1753 //____________________________________________________________________________
1754 void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
1755 {  // Read the summable digits fron treeS()
1756
1757
1758   TString filename("mergefile") ;
1759   filename+= input ;
1760
1761   TFolder * phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
1762   if ( !phosFolder ) {
1763    phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ;
1764   }
1765   TFolder * folder=(TFolder*)phosFolder->FindObject(filename) ;
1766   //set address of the SDigits and SDigitizer
1767   TBranch   * sdigitsBranch    = 0;
1768   TBranch   * sdigitizerBranch = 0;
1769   TBranch   * branch           = 0 ;
1770   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
1771   TIter next(lob) ;
1772   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ;
1773
1774   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
1775     if ( strcmp(branch->GetName(), "PHOS")==0) {
1776       phosfound = kTRUE ;
1777       sdigitsBranch = branch ;
1778     }
1779
1780     else if ( strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) {
1781       sdigitizerfound = kTRUE ;
1782       sdigitizerBranch = branch ;
1783     }
1784   }
1785   if ( !phosfound || !sdigitizerfound ) {
1786     if (fDebug)
1787       cout << "WARNING: AliPHOSGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
1788     return ;
1789   }
1790
1791   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
1792     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
1793
1794   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
1795   sdigitsBranch->GetEntry(0) ;
1796
1797   TString sdname(sdigitsBranch->GetTitle()) ;
1798   sdname+=":" ;
1799   sdname+=filename ;
1800   if(!SDigitizer(sdigitsBranch->GetTitle()) )
1801     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
1802
1803   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1804   sdigitizerBranch->GetEntry(0) ;
1805
1806 }
1807
1808
1809 //____________________________________________________________________________
1810 void AliPHOSGetter::ReadPrimaries()
1811 {
1812   // a lot simplified.... if 2 files are opened then we have a problem
1813
1814   TClonesArray * ar = 0  ;
1815   if(! (ar = Primaries()) ) {
1816     PostPrimaries() ;
1817     ar = Primaries() ;
1818   }
1819   ar->Delete() ;
1820
1821   fNPrimaries = gAlice->GetNtrack() ;
1822   Int_t index = 0 ;
1823   for (index = 0 ; index < fNPrimaries; index++) {
1824     new ((*ar)[index]) TParticle(*(Primary(index)));
1825   }
1826 }
1827 //____________________________________________________________________________
1828 void AliPHOSGetter::Event(const Int_t event, const char* opt)
1829 {
1830   // Reads the content of all Tree's S, D and R
1831
1832   if (event >= gAlice->TreeE()->GetEntries() ) {
1833     cerr << "ERROR: AliPHOSGetter::Event -> " << event << " not found in TreeE!" << endl ;
1834     return ;
1835   }
1836
1837   Bool_t any = kFALSE ;
1838   if (strstr(opt,"A") ) // do not check the title of the branches
1839     any = kTRUE;
1840
1841   gAlice->GetEvent(event) ;
1842
1843   Int_t rvRH = 0 ;
1844   Int_t rvRS = 0 ;
1845   Int_t rvRD = 0 ;
1846   Int_t rvRR = 0 ;
1847
1848   if(strstr(opt,"H") )
1849     rvRH = ReadTreeH() ;
1850
1851   if(strstr(opt,"S") )
1852     rvRS = ReadTreeS(event) ;
1853
1854   if( strstr(opt,"D") )
1855     rvRD = ReadTreeD() ;
1856
1857   if( strstr(opt,"R") )
1858     rvRR = ReadTreeR(any) ;
1859
1860   if( strstr(opt,"Q") )
1861     ReadTreeQA() ;
1862
1863   if( strstr(opt,"P") || (strcmp(opt,"")==0) )
1864     if ( gAlice->Stack() )
1865       ReadPrimaries() ;
1866
1867 }
1868
1869 //____________________________________________________________________________
1870 TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file) const
1871 {
1872   // get the object named "what" from the folder
1873   // folders are named like //Folders
1874
1875   if ( file.IsNull() )
1876     file = fHeaderFile ;
1877
1878   TFolder * folder = 0 ;
1879   TObject * phosO  = 0 ;
1880
1881   //  if ( name.IsNull() ) {
1882   if ( what.CompareTo("Primaries") == 0 ) {
1883     folder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
1884     if (folder)
1885       phosO  = dynamic_cast<TObject *>(folder->FindObject("Primaries")) ;
1886   }
1887   else if ( what.CompareTo("Hits") == 0 ) {
1888     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("PHOS")) ;
1889     if (folder)
1890       phosO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;
1891   }
1892   else if ( what.CompareTo("SDigits") == 0 ) {
1893     file.ReplaceAll("/","_") ;
1894     TString path = "PHOS/" + file  ;
1895     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ;
1896     if (folder) {
1897       if (name.IsNull())
1898         name = fSDigitsTitle ;
1899       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1900     }
1901   }
1902   else if ( what.CompareTo("Digits") == 0 ){
1903     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("PHOS")) ;
1904     if (folder) {
1905       if (name.IsNull())
1906         name = fDigitsTitle ;
1907       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1908     }
1909   }
1910   else if ( what.CompareTo("EmcRecPoints") == 0 ) {
1911     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
1912     if (folder) {
1913       if (name.IsNull())
1914         name = fRecPointsTitle ;
1915       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1916     }
1917   }
1918   else if ( what.CompareTo("CpvRecPoints") == 0 ) {
1919     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
1920     if (folder) {
1921       if (name.IsNull())
1922         name = fRecPointsTitle ;
1923       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1924     }
1925   }
1926   else if ( what.CompareTo("TrackSegments") == 0 ) {
1927     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
1928     if (folder) {
1929       if (name.IsNull())
1930         name = fTrackSegmentsTitle ;
1931       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1932     }
1933   }
1934   else if ( what.CompareTo("RecParticles") == 0 ) {
1935     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
1936    if (folder) {
1937       if (name.IsNull())
1938         name = fRecParticlesTitle ;
1939       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1940     }
1941  }
1942   else if ( what.CompareTo("Alarms") == 0 ){
1943     if (name.IsNull() )
1944       phosO = dynamic_cast<TObject *>(fQAFolder->FindObject("PHOS")) ;
1945     else {
1946       folder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ;
1947       if (!folder)
1948         phosO = 0 ;
1949       else
1950         phosO = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1951     }
1952   }
1953   if (!phosO) {
1954     if(fDebug)
1955       cerr << "ERROR : AliPHOSGetter::ReturnO -> Object " << what << " not found in " << fQAFolder->GetName() << endl ;
1956     return 0 ;
1957   }
1958
1959   return phosO ;
1960 }
1961
1962 //____________________________________________________________________________
1963 const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const
1964 {
1965   // get the TTask named "what" from the folder
1966   // folders are named like //Folders/Tasks/what/PHOS/name
1967
1968   TString search(what) ;
1969   if ( what.CompareTo("Clusterizer") == 0 )
1970     search = "Reconstructioner" ;
1971   else if ( what.CompareTo("TrackSegmentMaker") == 0 )
1972     search = "Reconstructioner" ;
1973   else if ( what.CompareTo("PID") == 0 )
1974     search = "Reconstructioner" ;
1975   else if ( what.CompareTo("QATasks") == 0 )
1976     search = "QA" ;
1977
1978   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ;
1979
1980   if (!tasks) {
1981     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << what << " not found!" << endl ;
1982     return 0 ;
1983   }
1984
1985   TTask * phosT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ;
1986   if (!phosT) {
1987     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << what << "/PHOS not found!" << endl ;
1988     return 0 ;
1989   }
1990
1991   TList * list = phosT->GetListOfTasks() ;
1992
1993   if (what.CompareTo("SDigitizer") == 0) {
1994     if ( name.IsNull() )
1995       name =  fSDigitsTitle ;
1996   } else  if (what.CompareTo("Digitizer") == 0){
1997     if ( name.IsNull() )
1998       name =  fDigitsTitle ;
1999   } else  if (what.CompareTo("Clusterizer") == 0){
2000     if ( name.IsNull() )
2001       name =  fRecPointsTitle ;
2002     name.Append(":clusterizer") ;
2003   }
2004   else  if (what.CompareTo("TrackSegmentMaker") == 0){
2005     if ( name.IsNull() )
2006       name =  fTrackSegmentsTitle ;
2007     name.Append(":tracksegmentmaker") ;
2008   }
2009   else  if (what.CompareTo("PID") == 0){
2010     if ( name.IsNull() )
2011       name =  fRecParticlesTitle ;
2012     name.Append(":pid") ;
2013   }
2014   else  if (what.CompareTo("QATasks") == 0){
2015     if ( name.IsNull() )
2016       return phosT ;
2017   }
2018
2019   TIter it(list) ;
2020   TTask * task = 0 ;
2021   while((task = static_cast<TTask *>(it.Next()) )){
2022     TString taskname(task->GetName()) ;
2023     if(taskname.BeginsWith(name))
2024       return task ;
2025   }
2026
2027   if(fDebug)
2028     cout << "WARNING: AliPHOSGetter::ReturnT -> Task " << search << "/" << name << " not found!" << endl ;
2029   return 0 ;
2030 }