PHOS/AliPHOSGetter.cxx

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