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