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 "AliEMCALGeometry.h"
  78
  79 ClassImp(AliEMCALGetter)
  80
  81   AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ;
  82   TFile * AliEMCALGetter::fFile = 0 ;
  83
  84 //____________________________________________________________________________
  85
  86 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle, const Bool_t toSplit)
  87 {
  88   // This is the ctor called by GetInstance and the only one that can be used
  89
  90   if ( fHeaderFile.Contains("_") ) {
  91     Fatal("AliEMCALGetter","Invalid file name (_ not allowed) %s",fHeaderFile.Data()) ;
  92   }
  93
  94   //Initialize  all data
  95
  96   fFailed = kFALSE ;
  97   fDebug  = 0 ;
  98   fToSplit    = toSplit ;
  99   fHeaderFile = headerFile ;
 100
 101   fPrimaries = new TObjArray(1) ;
 102
 103   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules"));
 104   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data"));
 105   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits"));
 106   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits"));
 107   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data"));
 108   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData"));
 109   //fQAFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA"));
 110   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ;
 111
 112   //Set titles to branches and create PHOS specific folders
 113
 114   SetTitle(branchTitle) ;
 115
 116   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
 117
 118     //open headers file
 119
 120     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
 121
 122     if(!fFile){    //if file was not opened yet, read gAlice
 123       fFile = TFile::Open(fHeaderFile.Data(), "update") ;
 124       if (!fFile->IsOpen()) {
 125         Error("AliEMCALGetter","Cannot open %s",fHeaderFile.Data()) ;
 126         fFailed = kTRUE ;
 127         return ;
 128       }
 129       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
 130     }
 131   }
 132
 133   if (!gAlice) {
 134     Error("AliEMCALGetter","Cannot find gAlice in %s",fHeaderFile.Data()) ;
 135     fFailed = kTRUE ;
 136     return ;
 137   }
 138
 139   if (!EMCAL()) {
 140     if (fDebug)
 141       Info("AliEMCALGetter","Posting EMCAL to Folders") ;
 142
 143     if (gAlice->GetDetector("EMCAL")) {
 144       AliConfig * conf = AliConfig::Instance() ;
 145       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ;
 146       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
 147     }
 148     else
 149       Error("AliEMCALGetter"," Detector EMCAL not found");
 150   }
 151
 152   fDebug=0;
 153 }
 154
 155 //____________________________________________________________________________
 156
 157 AliEMCALGetter::~AliEMCALGetter()
 158 {
 159   if (fPrimaries) {
 160     fPrimaries->Delete() ;
 161     delete fPrimaries ;
 162   }
 163
 164   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
 165   TCollection * folderslist = emcalF->GetListOfFolders() ;
 166   TIter next(folderslist) ;
 167   TFolder * folder = 0 ;
 168
 169   while ( (folder = static_cast<TFolder*>(next())) )
 170     emcalF->Remove(folder) ;
 171
 172   if (fFile) {
 173     fFile->Close() ;
 174     delete fFile ;
 175     fFile = 0 ;
 176   }
 177
 178   fgObjGetter = 0 ;
 179 }
 180
 181 //____________________________________________________________________________
 182
 183 void AliEMCALGetter::CloseFile()
 184 {
 185   delete gAlice ;
 186   gAlice = 0 ;
 187 }
 188
 189 //____________________________________________________________________________
 190
 191 const TFolder * AliEMCALGetter::Folder(const TString what) const {
 192
 193   // returns the EMCAL folder required by what
 194   // what = hits, sdigits, digits
 195
 196   if ( what == "hits" )
 197     return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
 198   else if ( what == "sdigits" )
 199     return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
 200   else if ( what == "digits" )
 201     return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("EMCAL")) ;
 202   else {
 203     Error("GetFolder","%s illegal option (hits, sdigits, digits) ", what.Data()) ;
 204     return 0 ;
 205   }
 206 }
 207
 208 //____________________________________________________________________________
 209
 210 AliEMCALGetter * AliEMCALGetter::GetInstance()
 211 {
 212   // Returns the pointer of the unique instance already defined
 213
 214   if ( fgObjGetter ) {
 215     return fgObjGetter ;
 216   }
 217   else {
 218     return 0 ;
 219   }
 220 }
 221
 222 //____________________________________________________________________________
 223
 224 AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
 225                                              const char* branchTitle,
 226                                              const Bool_t toSplit)
 227 {
 228   // Creates and returns the pointer of the unique instance
 229   // Must be called only when the environment has changed
 230
 231   if(!fgObjGetter){
 232     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
 233     if(fgObjGetter->fFailed)
 234       return 0;
 235     else
 236       return fgObjGetter ;
 237   }
 238
 239   //First checks, if header file already opened
 240
 241   if(!fgObjGetter->fFile){
 242      fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
 243     if(fgObjGetter->fFailed)
 244       return 0;
 245     else
 246       return fgObjGetter ;
 247   }
 248
 249   if(fgObjGetter->fHeaderFile.CompareTo(headerFile)==0){ //Opened the same header file
 250     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0)&&   //Open the same branch title
 251        (toSplit==fgObjGetter->fToSplit)){                          //Nothing should be cleaned
 252     }
 253     else{ //Clean all data and AliEMCAL...zers
 254       if(fgObjGetter->fToSplit)
 255         fgObjGetter->CloseSplitFiles() ;
 256       fgObjGetter->CleanWhiteBoard() ;
 257       fgObjGetter->fToSplit = toSplit ;
 258       fgObjGetter->SetTitle(branchTitle) ;
 259     }
 260   }
 261   else{  //Close already opened files, clean memory and open new header file
 262     if(gAlice)
 263       delete gAlice ;
 264     gAlice= 0;
 265     if(fgObjGetter->fFile){
 266       fgObjGetter->fFile->Close() ;
 267       fgObjGetter->fFile=0;
 268     }
 269     if(fgObjGetter->fToSplit)
 270       fgObjGetter->CloseSplitFiles() ;
 271     fgObjGetter->CleanWhiteBoard() ;
 272     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
 273   }
 274
 275   return fgObjGetter ;
 276
 277 }
 278
 279 //____________________________________________________________________________
 280
 281 const Bool_t AliEMCALGetter::BranchExists(const TString recName) const
 282 {
 283   //Looks in the tree Tree"name" if branch with current name olready exists
 284
 285   TString filename("") ;
 286   TString name, dataname, zername;
 287   if(recName == "SDigits"){
 288     filename=fSDigitsFileName ;
 289     name = "TreeS0" ;
 290     dataname = "EMCAL" ;
 291     zername = "AliEMCALSDigitizer" ;
 292   }
 293   else if(recName == "Digits"){
 294     filename=fDigitsFileName ;
 295     name = "TreeD0" ;
 296     dataname = "EMCAL" ;
 297     zername = "AliEMCALDigitizer" ;
 298   }
 299   else if(recName =="RecPoints"){
 300         filename=fRecPointsFileName ;
 301         name = "TreeR0" ;
 302         dataname = "EMCALEmcRP" ;
 303         zername = "AliEMCALClusterizer" ;
 304   }
 305   else if(recName == "TrackSegments"){
 306     filename=fTrackSegmentsFileName ;
 307     name = "TreeR0" ;
 308     dataname = "EMCALTS" ;
 309     zername = "AliEMCALTrackSegmentMaker" ;
 310   }
 311   else if(recName == "RecParticles"){
 312     filename= fRecParticlesFileName ;
 313     name = "TreeR0" ;
 314     dataname = "EMCALRP" ;
 315     zername = "AliEMCALPID" ;
 316   }
 317   else
 318     return kFALSE ;
 319
 320   TFile * file ;
 321   TTree * tree ;
 322   if(fToSplit){
 323     file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
 324     if(!file)
 325       file = TFile::Open(fSDigitsFileName.Data(),"update");
 326   }
 327   else
 328     file = fFile ;
 329
 330   tree = (TTree *)file->Get(name.Data()) ;
 331
 332   if(!tree )
 333     return kFALSE ;
 334
 335   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
 336   TIter next(lob) ;
 337   TBranch * branch = 0 ;
 338   TString titleName(fBranchTitle);
 339   titleName+=":";
 340
 341   while ((branch = (static_cast<TBranch*>(next())))) {
 342     TString branchName(branch->GetName() ) ;
 343     TString branchTitle(branch->GetTitle() ) ;
 344     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){
 345       Warning("BranchExists", "branch %s with title %s already exits in %s", dataname.Data(), fBranchTitle.Data(), name.Data());
 346       return kTRUE ;
 347     }
 348
 349     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
 350       Warning("BranchExists","Branch AliEMCAL... with title %s already exits in %s",branch->GetTitle(), name.Data());
 351       return kTRUE ;
 352     }
 353   }
 354
 355     //We can't delete three if gAlice points to it... To be redisigned somehow???!!!
 356
 357   if(!fToSplit){
 358     if(name.Contains("TreeS"))
 359       if(tree!=gAlice->TreeS())
 360         tree->Delete();
 361     if(name.Contains("TreeD"))
 362       if(tree!=gAlice->TreeD())
 363         tree->Delete();
 364     if(name.Contains("TreeR"))
 365       if(tree!=gAlice->TreeR())
 366         tree->Delete();
 367   }
 368
 369   return kFALSE ;
 370 }
 371
 372 //____________________________________________________________________________
 373
 374 void AliEMCALGetter::ListBranches(Int_t event) const
 375 {
 376   TBranch * branch = 0 ;
 377   if (gAlice->GetEvent(event) == -1)
 378     return ;
 379
 380   TTree * t =  gAlice->TreeH() ;
 381
 382   if(t){
 383     Info("ListBranches"," -> ****** Hits    : ");
 384     TObjArray * lob = t->GetListOfBranches() ;
 385     TIter next(lob) ;
 386
 387     while ( (branch = static_cast<TBranch*>(next())) )
 388       Info("ListBranches","         %s", branch->GetName());
 389
 390   } else
 391     Warning("ListBranches"," -> TreeH not found for event %d",event);
 392
 393   t = gAlice->TreeS() ;
 394
 395   if(t){
 396     Info("ListBranches"," -> ****** SDigits : ");
 397     TObjArray * lob = t->GetListOfBranches() ;
 398     TIter next(lob) ;
 399
 400     while ( (branch = static_cast<TBranch*>(next())) )
 401       Info("ListBranches","             %s %s",branch->GetName(),branch->GetTitle());
 402   } else
 403     Warning("ListBranches"," -> TreeS not found for event %d",event);
 404
 405   t = gAlice->TreeD() ;
 406
 407   if(t){
 408     Info("ListBranches"," -> ****** Digits  : ");
 409     TObjArray * lob = t->GetListOfBranches() ;
 410     TIter next(lob) ;
 411
 412     while ( (branch = static_cast<TBranch*>(next())) )
 413       Info("             %s %s", branch->GetName(), branch->GetTitle());
 414   } else
 415     Warning("ListBranches"," -> TreeD not found for event %d", event);
 416
 417   t = gAlice->TreeR() ;
 418
 419   if(t){
 420     Info("ListBranches"," -> ****** Recon   : ");
 421     TObjArray * lob = t->GetListOfBranches() ;
 422     TIter next(lob) ;
 423     while ( (branch = static_cast<TBranch*>(next())) )
 424       Info("             %s %s", branch->GetName(), branch->GetTitle());
 425   } else
 426     Warning("ListBranches"," -> TreeR not found for event %d",event);
 427 }
 428
 429 //____________________________________________________________________________
 430
 431 void AliEMCALGetter::NewBranch(TString name, Int_t event)
 432 {
 433   fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ;
 434   Event(event) ;
 435 }
 436
 437 //____________________________________________________________________________
 438
 439 Bool_t AliEMCALGetter::NewFile(TString name)
 440 {
 441   fHeaderFile = name ;
 442   fFile->Close() ;
 443   fFailed = kFALSE;
 444
 445   fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
 446
 447   if(!fFile) {    //if file was not opened yet, read gAlice
 448     fFile = TFile::Open(fHeaderFile.Data(),"update") ;
 449     if (!fFile->IsOpen()) {
 450       Error("NewFile", " -> Cannot open %s", fHeaderFile.Data());
 451       fFailed = kTRUE ;
 452       return fFailed ;
 453     }
 454     gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
 455   }
 456
 457   if (!gAlice) {
 458     Error("NewFile"," -> Cannot find gAlice in %s", fHeaderFile.Data());
 459     fFailed = kTRUE ;
 460     return fFailed ;
 461   }
 462   return fFailed ;
 463 }
 464
 465 //____________________________________________________________________________
 466
 467 const AliEMCAL * AliEMCALGetter::EMCAL()
 468 {
 469   // returns the EMCAL object
 470
 471   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(fModuleFolder->FindObject("EMCAL")) ;
 472
 473   if (!emcal)
 474     if (fDebug)
 475       Warning("EMCAL"," -> EMCAL module not found in Folders" );
 476   return emcal ;
 477 }
 478
 479 //____________________________________________________________________________
 480
 481 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry()
 482 {
 483   AliEMCALGeometry * rv = 0 ;
 484   if (EMCAL() )
 485     rv =  EMCAL()->GetGeometry() ;
 486   return rv ;
 487 }
 488
 489 //____________________________________________________________________________
 490
 491 const Bool_t AliEMCALGetter::PostPrimaries(void) const
 492 {
 493   //------- Primaries ----------------------
 494   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
 495
 496   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ;
 497   if ( !primariesFolder ) {
 498     if (fDebug) {
 499       Warning("PostPrimaries", "-> Folder //%s/Primaries/ not found!", fPrimariesFolder->GetName());
 500       Info("PostPrimaries", "-> Adding Folder //%s/Primaries/",fPrimariesFolder->GetName());
 501     }
 502     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ;
 503   }
 504
 505   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
 506   primaries->SetName("Primaries") ;
 507   primariesFolder->Add(primaries) ;
 508
 509   return kTRUE;
 510 }
 511
 512 //____________________________________________________________________________
 513
 514 TObject** AliEMCALGetter::PrimariesRef(void) const
 515 {
 516   //------- Primaries ----------------------
 517   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
 518
 519   if ( !fPrimariesFolder ) {
 520     Fatal("PrimariesRef", "-> Folder //%s not found!",fPrimariesFolder);
 521   }
 522
 523   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
 524
 525   if ( !primariesFolder ) {
 526     Fatal("PrimariesRef", "-> Folder //%s/Primaries/ not found!",fPrimariesFolder);
 527   }
 528
 529   TObject * p = primariesFolder->FindObject("Primaries") ;
 530
 531   if(!p) {
 532     Fatal("PrimariesRef", "-> %s/Primaries not found !",primariesFolder->GetName());
 533   }
 534
 535   return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
 536 }
 537
 538 //____________________________________________________________________________
 539
 540 const Bool_t AliEMCALGetter::PostHits(void) const
 541 {
 542   //------- Hits ----------------------
 543   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
 544
 545   TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
 546
 547   if ( !emcalFolder ) {
 548     if (fDebug) {
 549       Warning("PostHits", "-> Folder //%s/EMCAL/ not found!", fHitsFolder);
 550       Info("PostHits", "-> Adding Folder //%s/EMCAL/",fHitsFolder);
 551     }
 552     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ;
 553   }
 554
 555   TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
 556   hits->SetName("Hits") ;
 557   emcalFolder->Add(hits) ;
 558
 559   return kTRUE;
 560 }
 561
 562 //____________________________________________________________________________
 563
 564 TObject ** AliEMCALGetter::HitsRef(void) const
 565 {
 566   //------- Hits ----------------------
 567   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
 568
 569   if ( !fHitsFolder ) {
 570     Error("HitsRef", "-> Folder //%s not found!",fHitsFolder);
 571     return 0;
 572   }
 573
 574   TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
 575   if ( !emcalFolder ) {
 576     Error("HitsRef", "-> Folder //%s/EMCAL/ not found!",fHitsFolder);
 577     return 0;
 578   }
 579
 580   TObject * h = emcalFolder->FindObject("Hits") ;
 581
 582   if(!h) {
 583     Error("HitsRef", "-> %s/Hits not found !",emcalFolder->GetName());
 584     return 0 ;
 585   }
 586   else
 587     return emcalFolder->GetListOfFolders()->GetObjectRef(h) ;
 588 }
 589
 590 //____________________________________________________________________________
 591
 592 const Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const
 593 {
 594   //---------- SDigits -------------------------
 595   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
 596   // because you can have sdigits from several hit files for mixing
 597
 598   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
 599
 600   if ( !emcalFolder ) {
 601     if (fDebug) {
 602       Warning("PostSDigits", "-> Folder //%s/EMCAL/ not found!", fSDigitsFolder);
 603       Info("PostSDigits", "-> Adding Folder //%s/EMCAL/",fHitsFolder);
 604     }
 605     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
 606   }
 607
 608   TString subdir(headerFile) ;
 609   subdir.ReplaceAll("/", "_") ;
 610   TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ;
 611   if ( !emcalSubFolder )
 612     emcalSubFolder = emcalFolder->AddFolder(subdir, "");
 613
 614   TObject * sd  = emcalSubFolder->FindObject(name);
 615
 616   if ( !sd ) {
 617     TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1) ;
 618     sdigits->SetName(name) ;
 619     emcalSubFolder->Add(sdigits) ;
 620   }
 621
 622   return kTRUE;
 623 }
 624
 625 //____________________________________________________________________________
 626
 627 TObject ** AliEMCALGetter::SDigitsRef(const char * name, const char * file) const
 628 {
 629   //------- SDigits ----------------------
 630   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
 631
 632   if ( !fSDigitsFolder ) {
 633     Fatal("SDigitsRef", "-> Folder //%s not found!", fSDigitsFolder);
 634   }
 635
 636   TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
 637
 638   if ( !emcalFolder ) {
 639     Fatal("SDigitsRef", "-> Folder //%s/EMCAL/ not found!", fSDigitsFolder);
 640   }
 641
 642   TFolder * emcalSubFolder = 0 ;
 643
 644   if(file)
 645     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
 646   else
 647     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
 648
 649   if(!emcalSubFolder) {
 650     Fatal("SDigitsRef", "-> Folder //Folders/RunMC/Event/Data/EMCAL/%s not found!", file);
 651   }
 652
 653   TObject * dis = emcalSubFolder->FindObject(name) ;
 654
 655   if(!dis) {
 656     Fatal("SDigitsRef", "-> object %s not found!", name);
 657   }
 658
 659   return emcalSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
 660 }
 661
 662 //____________________________________________________________________________
 663
 664 const Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const
 665 {
 666   //---------- SDigitizer -------------------------
 667   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 668
 669   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 670
 671   if ( !sd ) {
 672     Error("PostSDigitizer", "-> Task //%s/SDigitizer not found!",fTasksFolder);
 673     return kFALSE ;
 674   }
 675
 676   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 677
 678   if ( !emcal )  {
 679     if (fDebug) {
 680       Warning("PostSDigitizer", "->//%s/SDigitizer/EMCAL/ not found!",fTasksFolder);
 681       Info("PostSDigitizer", "-> Adding //%s/SDigitizer/EMCAL/", fTasksFolder);
 682     }
 683     emcal = new TTask("EMCAL", "") ;
 684     sd->Add(emcal) ;
 685   }
 686
 687   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() ));
 688
 689   if (emcalsd) {
 690     if (fDebug)
 691       Info("PostSDigitizer", "-> Task %s already exists",sdigitizer->GetName());
 692     emcal->GetListOfTasks()->Remove(emcalsd) ;
 693   }
 694
 695   emcal->Add(sdigitizer) ;
 696
 697   return kTRUE;
 698 }
 699
 700 //____________________________________________________________________________
 701
 702 TObject ** AliEMCALGetter::SDigitizerRef(const char * name) const
 703 {
 704   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 705
 706   if ( !sd ) {
 707     Fatal("SDigitizerRef", "-> Task //%s/SDigitizer not found!", fTasksFolder);
 708   }
 709
 710   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 711
 712   if ( !emcal )  {
 713     Fatal("SDigitizerRef", "->  //%s/SDigitizer/EMCAL not found!", fTasksFolder);
 714   }
 715
 716   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ;
 717
 718   return emcal->GetListOfTasks()->GetObjectRef(task) ;
 719 }
 720
 721 //____________________________________________________________________________
 722
 723 const Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const
 724 {
 725   //---------- SDigitizer -------------------------
 726   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 727
 728   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 729
 730   if ( !sd ) {
 731     Error("PostSDigitizer", "-> Task //%s/SDigitizer not found!", fTasksFolder);
 732     return kFALSE ;
 733   }
 734
 735   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 736
 737   if ( !emcal )  {
 738     if (fDebug) {
 739       Warning("PostSDigitizer", "->  //%s/SDigitizer/EMCAL/ not found!", fTasksFolder);
 740
 741       Info("PostSDigitizer", "-> Adding  //%s/SDigitizer/EMCAL", fTasksFolder);
 742
 743     }
 744     emcal = new TTask("EMCAL", "") ;
 745     sd->Add(emcal) ;
 746   }
 747
 748   TString sdname(name) ;
 749   sdname.Append(":") ;
 750   sdname.Append(file);
 751   sdname.ReplaceAll("/","_") ;
 752   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname ));
 753
 754   if (!emcalsd) {
 755     emcalsd = new AliEMCALSDigitizer() ;
 756
 757     //Note, we can not call constructor with parameters: it will call Getter and screw up everething
 758
 759     emcalsd->SetName(sdname) ;
 760     emcalsd->SetTitle(file) ;
 761     emcal->Add(emcalsd) ;
 762   }
 763
 764   return kTRUE;
 765 }
 766
 767 //____________________________________________________________________________
 768
 769 const Bool_t AliEMCALGetter::PostDigits(const char * name) const
 770 {
 771   //---------- Digits -------------------------
 772   // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name
 773
 774   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
 775
 776   if ( !emcalFolder ) {
 777     if (fDebug) {
 778       Warning("PostDigits", "-> Folder //%s/EMCAL/ not found!", fDigitsFolder);
 779       Info("PostDigits", "-> Adding Folder //%s/EMCAL/", fDigitsFolder);
 780     }
 781     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;
 782   }
 783
 784   TObject*  dig = emcalFolder->FindObject( name ) ;
 785
 786   if ( !dig ) {
 787     TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ;
 788     digits->SetName(name) ;
 789     emcalFolder->Add(digits) ;
 790   }
 791
 792   return kTRUE;
 793 }
 794
 795 //____________________________________________________________________________
 796
 797 TObject ** AliEMCALGetter::DigitsRef(const char * name) const
 798 {
 799   //------- Digits ----------------------
 800   // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name
 801
 802   if ( !fDigitsFolder ) {
 803     Fatal("DigitsRef", "-> Folder //%s not found!", fDigitsFolder);
 804   }
 805
 806   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
 807
 808   if ( !emcalFolder ) {
 809     Fatal("DigitsRef", "-> Folder //%s/EMCAL/ not found!", fDigitsFolder);
 810   }
 811
 812   TObject * d = emcalFolder->FindObject(name) ;
 813
 814   if(!d) {
 815     Fatal("DigitsRef", "-> object %s not found!", name);
 816   }
 817
 818   return emcalFolder->GetListOfFolders()->GetObjectRef(d) ;
 819 }
 820
 821 //____________________________________________________________________________
 822
 823 const Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const
 824 {
 825   //---------- Digitizer -------------------------
 826
 827   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 828
 829   if ( !sd ) {
 830     Error("PostDigitizer", "-> Task //%s/Digitizer not found!", fTasksFolder);
 831     return kFALSE ;
 832   }
 833
 834   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 835
 836   if ( !emcal )  {
 837     if (fDebug) {
 838       Warning("PostDigitizer", "->  //%s/Digitizer/EMCAL not found!", fTasksFolder);
 839       Info("PostDigitizer", "-> Adding //%s/Digitizer/EMCAL", fTasksFolder);
 840     }
 841     emcal = new TTask("EMCAL", "") ;
 842     sd->Add(emcal) ;
 843   }
 844
 845     AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ;
 846
 847     if (emcald) {
 848       emcald->Delete() ;
 849       emcal->GetListOfTasks()->Remove(emcald) ;
 850     }
 851
 852     emcal->Add(digitizer) ;
 853
 854     return kTRUE;
 855 }
 856
 857 //____________________________________________________________________________
 858
 859 const Bool_t AliEMCALGetter::PostDigitizer(const char * name) const
 860 {
 861   //---------- Digitizer -------------------------
 862   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 863
 864   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 865
 866   if ( !d ) {
 867
 868     Error("PostDigitizer", "-> Task //%s/Digitizer not found!", fTasksFolder);
 869     return kFALSE ;
 870   }
 871
 872   TTask * emcal = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("EMCAL")) ;
 873
 874   if ( !emcal )  {
 875     if (fDebug) {
 876       Warning("PostDigitizer", "-> //%s/Digitizer/EMCAL not found!", fTasksFolder);
 877
 878       Info("PostDigitizer", "-> Adding //%s/Digitizer/EMCAL", fTasksFolder);
 879     }
 880     emcal = new TTask("EMCAL", "") ;
 881     d->Add(emcal) ;
 882 }
 883
 884   AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(name)) ;
 885
 886   if (!emcald) {
 887     emcald = new AliEMCALDigitizer() ;
 888     emcald->SetName(fDigitsTitle) ;
 889     emcald->SetTitle(fHeaderFile) ;
 890     emcal->Add(emcald) ;
 891   }
 892
 893   return kTRUE;
 894 }
 895
 896 //____________________________________________________________________________
 897
 898 TObject ** AliEMCALGetter::DigitizerRef(const char * name) const
 899 {
 900
 901   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 902
 903   if ( !sd ) {
 904     Fatal("DigitizerRef", "-> Task //%s/Digitizer not found!", fTasksFolder->GetName());
 905   }
 906
 907   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 908
 909   if ( !emcal )  {
 910     Fatal("DigitizerRef", "->  //%s/Digitizer/EMCAL", fTasksFolder->GetName());
 911   }
 912
 913   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ;
 914
 915   return emcal->GetListOfTasks()->GetObjectRef(task) ;
 916 }
 917
 918 //____________________________________________________________________________
 919
 920 const Bool_t AliEMCALGetter::PostRecPoints(const char * name) const
 921 {
 922   // -------------- RecPoints -------------------------------------------
 923   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
 924   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
 925
 926   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ;
 927
 928   if ( !emcalFolder ) {
 929     if (fDebug) {
 930       Warning("PostRecPoints", "-> Folder //%s/EMCAL/ not found!", fRecoFolder);
 931       Info("PostRecPoints", "-> Adding Folder //%s/EMCAL/", fRecoFolder);
 932     }
 933     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;
 934   }
 935
 936   // Tower RecPoints
 937
 938   TFolder * emcalRPoTowerFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TowerRecPoints")) ;
 939
 940   if ( !emcalRPoTowerFolder ) {
 941     if (fDebug) {
 942
 943       Warning("PostRecPoints", "-> Folder //%s/EMCAL/TowerRecPoints/ not found!", fRecoFolder);
 944       Info("PostRecPoints", "-> Adding Folder //%s/EMCAL/TowerRecPoints not found!", fRecoFolder);
 945     }
 946     emcalRPoTowerFolder = emcalFolder->AddFolder("TowerRecPoints", "Tower RecPoints from EMCAL") ;
 947   }
 948
 949   TObject * erp = emcalFolder->FindObject( name ) ;
 950
 951   if ( !erp )   {
 952     TObjArray * towerrp = new TObjArray(100) ;
 953     towerrp->SetName(name) ;
 954     emcalRPoTowerFolder->Add(towerrp) ;
 955   }
 956
 957   // Pre Shower RecPoints
 958
 959   TFolder * emcalRPoPreShoFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("PreShowerRecPoints")) ;
 960
 961   if ( !emcalRPoPreShoFolder ) {
 962     if (fDebug) {
 963       Warning("PostRecPoints", "-> Folder //%s/EMCAL/PreShowerRecPoints/ not found!", fRecoFolder);
 964       Info("PostRecPoints", "-> Adding Folder //%s/EMCAL/PreShowerRecPoints/", fRecoFolder);
 965     }
 966     emcalRPoPreShoFolder = emcalFolder->AddFolder("PreShowerRecPoints", "PreSho RecPoints from EMCAL") ;
 967   }
 968
 969   TObject * crp =  emcalRPoPreShoFolder->FindObject( name ) ;
 970
 971   if ( !crp )   {
 972     TObjArray * preshorp = new TObjArray(100) ;
 973     preshorp->SetName(name) ;
 974     emcalRPoPreShoFolder->Add(preshorp) ;
 975   }
 976
 977   return kTRUE;
 978 }
 979
 980 //____________________________________________________________________________
 981
 982 TObject ** AliEMCALGetter::TowerRecPointsRef(const char * name) const
 983 {
 984   // -------------- RecPoints -------------------------------------------
 985   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
 986
 987   if ( !fRecoFolder ) {
 988     Fatal("TowerRecPointsRef", "-> Folder //%s not found!", fRecoFolder);
 989   }
 990
 991   TFolder * towerFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ;
 992
 993   if ( !towerFolder ) {
 994     Fatal("TowerRecPointsRef", "-> Folder //%s/EMCAL/TowerRecPoints/ not found!", fRecoFolder);
 995   }
 996
 997   TObject * trp = towerFolder->FindObject(name ) ;
 998
 999   if ( !trp )   {
1000     Fatal("TowerRecPointsRef", "-> Object %s not found!", name);
1001   }
1002
1003   return towerFolder->GetListOfFolders()->GetObjectRef(trp) ;
1004 }
1005
1006 //____________________________________________________________________________
1007
1008 TObject ** AliEMCALGetter::PreShowerRecPointsRef(const char * name) const
1009 {
1010   // -------------- RecPoints -------------------------------------------
1011   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
1012
1013   if ( !fRecoFolder ) {
1014     Fatal("PreShowerRecPointsRef", "-> Folder //%s not found!", fRecoFolder);
1015   }
1016
1017   TFolder * preshoFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ;
1018
1019   if ( !preshoFolder ) {
1020     Fatal("PreShowerRecPointsRef", "-> Folder //%s/EMCAL/PreShowerRecPoints/", fRecoFolder);
1021   }
1022
1023
1024
1025   TObject * prp = preshoFolder->FindObject(name ) ;
1026
1027   if ( !prp )   {
1028     Fatal("PreShowerRecPointsRef", "-> Object %s not found!", name);
1029   }
1030
1031   return preshoFolder->GetListOfFolders()->GetObjectRef(prp) ;
1032 }
1033
1034 //____________________________________________________________________________
1035
1036 const Bool_t AliEMCALGetter::PostClusterizer(AliEMCALClusterizer * clu) const
1037 {
1038   // ------------------ AliEMCALClusterizer ------------------------
1039   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
1040
1041   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1042
1043   if ( !tasks ) {
1044     Error("PostClusterizer", "-> Task //%s/Reconstructioner not found!", fTasksFolder);
1045     return kFALSE ;
1046   }
1047
1048   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ;
1049
1050   if ( !emcal )  {
1051     if (fDebug) {
1052       Warning("PostClusterizer", "-> //%s/ReconstructionerEMCAL not found!", fTasksFolder);
1053       Info("PostClusterizer", "-> Adding //%s/Reconstructioner/EMCAL", fTasksFolder);
1054     }
1055     emcal = new TTask("EMCAL", "") ;
1056     tasks->Add(emcal) ;
1057   }
1058
1059   AliEMCALClusterizerv1 * emcalcl = dynamic_cast<AliEMCALClusterizerv1*>(emcal->GetListOfTasks()->FindObject(clu->GetName())) ;
1060
1061   if (emcalcl) {
1062     if (fDebug)
1063       Info("PostClusterizer", "-> Task %s already exists", clu->GetName());
1064     emcalcl->Delete() ;
1065     emcal->GetListOfTasks()->Remove(emcalcl) ;
1066   }
1067   emcal->Add(clu) ;
1068
1069   return kTRUE;
1070 }
1071
1072 //____________________________________________________________________________
1073
1074 TObject ** AliEMCALGetter::ClusterizerRef(const char * name) const
1075 {
1076   // ------------------ AliEMCALClusterizer ------------------------
1077
1078   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1079
1080   if ( !tasks ) {
1081     Fatal("ClusterizerRef", "-> Task //%s/Reconstructioner not found!", fTasksFolder->GetName());
1082   }
1083
1084   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ;
1085
1086   if ( !emcal )  {
1087     Fatal("ClusterizerRef", "-> //%s/Reconstructioner/EMCAL", fTasksFolder->GetName());
1088   }
1089
1090   TList * l = emcal->GetListOfTasks() ;
1091   TIter it(l) ;
1092   TTask * task ;
1093   TTask * clu = 0 ;
1094   TString cluname(name) ;
1095   cluname+=":clu-" ;
1096
1097   while((task = static_cast<TTask *>(it.Next()) )){
1098     TString taskname(task->GetName()) ;
1099     if(taskname.BeginsWith(cluname)){
1100       clu = task ;
1101       break ;
1102     }
1103   }
1104
1105   if(!clu) {
1106     Fatal("ClusterizerRef", "-> task %s not found!", task->GetName());
1107   }
1108
1109   return l->GetObjectRef(clu) ;
1110 }
1111
1112 //____________________________________________________________________________
1113
1114 const Bool_t AliEMCALGetter::PostClusterizer(const char * name) const
1115 {
1116   // ------------------ AliEMCALClusterizer ------------------------
1117   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
1118
1119
1120   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1121
1122   if ( !tasks ) {
1123     Error("PostClusterizer", "-> Task //%s/Reconstructioner not found!", fTasksFolder->GetName());
1124     return kFALSE ;
1125   }
1126
1127   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ;
1128
1129   if ( !emcal )  {
1130     if (fDebug) {
1131       Warning("PostClusterizer", "-> //%s/Reconstructioner/EMCAL not found!", fTasksFolder);
1132       Info("PostClusterizer", "-> Adding //%s/Reconstructioner/EMCAL", fTasksFolder);
1133     }
1134     emcal = new TTask("EMCAL", "") ;
1135     tasks->Add(emcal) ;
1136   }
1137
1138   TList * l = emcal->GetListOfTasks() ;
1139   TIter it(l) ;
1140   TString clun(name) ;
1141   clun+=":clu" ;
1142   TTask * task ;
1143
1144   while((task = static_cast<TTask *>(it.Next()) )){
1145     TString taskname(task->GetName()) ;
1146
1147     if(taskname.BeginsWith(clun))
1148       return kTRUE ;
1149   }
1150
1151   AliEMCALClusterizerv1 * emcalcl = new AliEMCALClusterizerv1() ;
1152
1153   clun+="-v1" ;
1154   emcalcl->SetName(clun) ;
1155   emcalcl->SetTitle(fHeaderFile) ;
1156   emcal->Add(emcalcl) ;
1157
1158   return kTRUE;
1159 }
1160
1161 //____________________________________________________________________________
1162
1163 TTree * AliEMCALGetter::TreeK(TString filename)
1164 {
1165   // returns TreeK from file filename
1166   // usefull in case of split file
1167
1168   if ( filename.IsNull() )
1169     filename = fHeaderFile ;
1170
1171   TFile * file = 0 ;
1172
1173   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1174
1175   if (!file)  {  // file not yet open
1176     file = TFile::Open(filename.Data(), "read") ;
1177   }
1178
1179   TString treeName("TreeK") ;
1180   treeName += EventNumber()  ;
1181   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1182
1183   if (!tree && fDebug)
1184     Warning("TreeK", "-> %s not found in %s", treeName.Data(),filename.Data());
1185
1186   return tree ;
1187 }
1188
1189 //____________________________________________________________________________
1190
1191 TTree * AliEMCALGetter::TreeH(TString filename)
1192 {
1193   // returns TreeH from file filename
1194   // usefull in case of split file
1195
1196   if ( filename.IsNull() )
1197     filename = fHeaderFile ;
1198
1199   TFile * file = 0 ;
1200   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1201
1202   if (!file) { // file not open yet
1203     file = TFile::Open(filename.Data(), "read") ;
1204   }
1205
1206   TString treeName("TreeH") ;
1207   treeName += EventNumber()  ;
1208   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1209
1210   if (!tree && fDebug)
1211     Warning("TreeH", "-> %s not found in %s", treeName.Data(), filename.Data());
1212   return tree ;
1213 }
1214
1215 //____________________________________________________________________________
1216
1217 TTree * AliEMCALGetter::TreeS(TString filename)
1218 {
1219   // returns TreeS from file filename
1220   // usefull in case of split file
1221
1222   if ( filename.IsNull() )
1223     filename = fHeaderFile ;
1224
1225   TFile * file = 0 ;
1226   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1227
1228   if (!file) { // file not open yet
1229     file = TFile::Open(filename.Data(), "read") ;
1230   }
1231
1232   TString treeName("TreeS") ;
1233   treeName += EventNumber()  ;
1234   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1235
1236   if (!tree && fDebug)
1237     Warning("TreeS", "-> %s not found in %s", treeName.Data(), filename.Data());
1238   return tree ;
1239 }
1240
1241 //____________________________________________________________________________
1242
1243 TTree * AliEMCALGetter::TreeD(TString filename)
1244 {
1245   // returns TreeD from file filename
1246   // usefull in case of split file
1247
1248   if ( filename.IsNull() )
1249     filename = fHeaderFile ;
1250
1251   TFile * file = 0 ;
1252   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1253
1254   if (!file) { // file not open yet
1255     file = TFile::Open(filename.Data(), "read") ;
1256   }
1257
1258   TString treeName("TreeD") ;
1259   treeName += EventNumber()  ;
1260   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1261
1262   if (!tree && fDebug)
1263     Warning("TreeD", "-> %s not found in %s", treeName.Data(), filename.Data());
1264   return tree ;
1265 }
1266
1267 //____________________________________________________________________________
1268
1269 const TParticle * AliEMCALGetter::Primary(Int_t index) const
1270 {
1271   // Return primary particle numbered by <index>
1272
1273   if(index < 0)
1274     return 0 ;
1275
1276   TParticle *  p = 0 ;
1277   p = gAlice->Particle(index) ;
1278
1279   return p ;
1280 }
1281
1282 //____________________________________________________________________________
1283
1284 const TParticle * AliEMCALGetter::Secondary(TParticle* p, Int_t index) const
1285 {
1286   // Return first (index=1) or second (index=2) secondary particle of primary particle p
1287
1288   if(index <= 0)
1289     return 0 ;
1290   if(index > 2)
1291     return 0 ;
1292
1293   if(p) {
1294     Int_t daughterIndex = p->GetDaughter(index-1) ;
1295     return  gAlice->Particle(daughterIndex) ;
1296   }
1297   else
1298     return 0 ;
1299 }
1300
1301 //____________________________________________________________________________
1302
1303 Int_t AliEMCALGetter::ReadTreeD(const Int_t event)
1304 {
1305   // Read the digit tree gAlice->TreeD()
1306
1307   TTree * treeD ;
1308   if(fToSplit){
1309     TFile * file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName));
1310     if(!file)
1311       file = TFile::Open(fDigitsFileName) ;
1312
1313     // Get Digits Tree header from file
1314
1315     TString treeName("TreeD") ;
1316     treeName += event ;
1317     treeD = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1318
1319     if(!treeD){ // TreeD not found in header file
1320       if (fDebug)
1321         Warning("ReadTreeD", "-> Cannot find TreeD in %s", fDigitsFileName.Data());
1322       return 1;
1323     }
1324   }
1325   else
1326     treeD = gAlice->TreeD() ;
1327
1328   TObjArray * lob = static_cast<TObjArray*>(treeD->GetListOfBranches()) ;
1329   TIter next(lob) ;
1330   TBranch * branch = 0 ;
1331   TBranch * digitsbranch = 0 ;
1332   TBranch * digitizerbranch = 0 ;
1333
1334   Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ;
1335
1336   while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !digitizerfound) ) {
1337     if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1338       digitsbranch = branch ;
1339       emcalfound = kTRUE ;
1340     }
1341     else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1342       digitizerbranch = branch ;
1343       digitizerfound = kTRUE ;
1344     }
1345   }
1346
1347   if ( !emcalfound || !digitizerfound ) {
1348     if (fDebug)
1349       Warning("ReadTreeD", "-> Cannot find Digits and/or Digitizer with name %s", fDigitsTitle.Data());
1350     return 2;
1351   }
1352
1353   //read digits
1354
1355   if(!Digits(fDigitsTitle) )
1356     PostDigits(fDigitsTitle);
1357   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1358   digitsbranch->GetEntry(0) ;
1359
1360   // read  the Digitizer
1361
1362   RemoveTask("D", fDigitsTitle) ; // I do not understand why I need that
1363   if(!Digitizer(fDigitsTitle))
1364     PostDigitizer(fDigitsTitle) ;
1365   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1366   digitizerbranch->GetEntry(0) ;
1367
1368   lob->Delete();
1369
1370   if(gAlice->TreeD()!=treeD)
1371     treeD->Delete();
1372
1373   return 0 ;
1374 }
1375
1376 //____________________________________________________________________________
1377
1378 Int_t AliEMCALGetter::ReadTreeH()
1379 {
1380   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
1381
1382   TTree * treeH = gAlice->TreeH() ;
1383
1384   if(!treeH) {// TreeH not found in header file
1385     if (fDebug)
1386       Warning("ReadTreeH", "-> Cannot find TreeH in %s", fHeaderFile.Data());
1387
1388     TString searchFileName("EMCAL.HITS") ;
1389     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
1390       searchFileName+="." ;
1391       searchFileName += fBranchTitle ;
1392     }
1393
1394     searchFileName+=".root" ;
1395
1396     if ( (treeH = TreeH(searchFileName)) ) { //found TreeH in the file which contains the hits
1397       if (fDebug)
1398         Info("ReadTreeH", "-> TreeH found in %s", searchFileName.Data());
1399     } else {
1400       Error("ReadTreeH", "-> TreeH not found ");
1401       return 1;
1402     }
1403   }
1404
1405   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("EMCAL")) ;
1406
1407   if ( !hitsbranch ) {
1408     if (fDebug)
1409       Warning("ReadTreeH", "-> Cannot find branch EMCAL");
1410     return 2;
1411   }
1412
1413   if(!Hits())
1414     PostHits() ;
1415
1416   if (hitsbranch->GetEntries() > 1 ) {
1417     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1418     TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000) ;
1419     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ;
1420     hitsbranch->SetAddress(&tempo) ;
1421
1422     Int_t index = 0 ;
1423     Int_t i = 0 ;
1424
1425     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
1426       hitsbranch->GetEntry(i) ;
1427       Int_t j = 0 ;
1428       for ( j = 0 ; j < tempo->GetEntries() ; j++) {
1429         const AliEMCALHit * hit = static_cast<const AliEMCALHit *>(tempo->At(j)) ;
1430         new((*hits)[index]) AliEMCALHit( *hit ) ;
1431         index++ ;
1432       }
1433     }
1434     delete tempo ;
1435   }
1436   else {
1437     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1438     hitsbranch->SetAddress(HitsRef()) ;
1439     hitsbranch->GetEntry(0) ;
1440   }
1441   return 0 ;
1442 }
1443
1444 //____________________________________________________________________________
1445
1446 void AliEMCALGetter::Track(const Int_t itrack)
1447 {
1448   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
1449   if(gAlice->TreeH()== 0){
1450     Error("ReadTreeH", "-> Cannot read TreeH ");
1451     return ;
1452   }
1453
1454   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
1455
1456   if ( !hitsbranch ) {
1457     if (fDebug)
1458       Warning("ReadTreeH", "-> Cannot find branch EMCAL");
1459     return ;
1460   }
1461
1462   if(!Hits())
1463     PostHits() ;
1464
1465   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1466   hitsbranch->SetAddress(HitsRef()) ;
1467   hitsbranch->GetEntry(itrack) ;
1468 }
1469
1470 //____________________________________________________________________________
1471
1472 void AliEMCALGetter::ReadTreeQA()
1473 {
1474   if (fDebug)
1475     Warning("ReadTreeQA", "-> %s not implemented", ClassName());
1476 }
1477
1478
1479
1480 //____________________________________________________________________________
1481
1482 Int_t AliEMCALGetter::ReadTreeR(const Int_t event)
1483
1484 {
1485   // Read the reconstrunction tree gAlice->TreeR()
1486   // A particularity has been introduced here :
1487   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
1488   //   being for example give in AliEMCALPID(fileName, title)
1489   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
1490   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
1491   // from a given set of TrackSegments (with a given name)
1492   // This is why any is NOT used to read the branch of RecParticles
1493   // any migh have become obsolete : to be checked
1494   // See AliEMCALPIDv1
1495
1496   TTree * treeR ;
1497
1498   if(fToSplit){
1499     TFile * file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName));
1500     if(!file)
1501       file = TFile::Open(fRecPointsFileName) ;
1502     // Get Digits Tree header from file
1503
1504     TString treeName("TreeR") ;
1505     treeName += event ;
1506     treeR = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1507
1508     if(!treeR){ // TreeR not found in header file
1509       if (fDebug)
1510         Warning("ReadTreeD", "-> Cannot find TreeR in %s", fRecPointsFileName.Data());
1511       return 1;
1512     }
1513   }
1514   else
1515     treeR = gAlice->TreeR() ;
1516
1517   // RecPoints
1518
1519   TObjArray * lob = static_cast<TObjArray*>(treeR->GetListOfBranches()) ;
1520   TIter next(lob) ;
1521   TBranch * branch = 0 ;
1522   TBranch * towerbranch = 0 ;
1523   TBranch * preshowerbranch = 0 ;
1524   TBranch * clusterizerbranch = 0 ;
1525
1526   Bool_t emcalTowerRPfound = kFALSE, emcalPreShoRPfound = kFALSE, clusterizerfound = kFALSE ;
1527
1528   while ( (branch = static_cast<TBranch*>(next())) && (!emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) ) {
1529     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 ) {
1530       if ( strcmp(branch->GetName(), "EMCALTowerRP")==0) {
1531         towerbranch = branch ;
1532         emcalTowerRPfound = kTRUE ;
1533       }
1534       else if ( strcmp(branch->GetName(), "EMCALPreShoRP")==0) {
1535         preshowerbranch = branch ;
1536         emcalPreShoRPfound = kTRUE ;
1537       }
1538       else if(strcmp(branch->GetName(), "AliEMCALClusterizer")==0){
1539         clusterizerbranch = branch ;
1540         clusterizerfound = kTRUE ;
1541       }
1542     }
1543   }
1544
1545   if ( !emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) {
1546     if (fDebug)
1547       Warning("ReadTreeR", "-> Cannot find RecPoints and/or Clusterizer with name %s", fRecPointsTitle.Data());
1548   }
1549   else {
1550     if(!TowerRecPoints(fRecPointsTitle) )
1551       PostRecPoints(fRecPointsTitle) ;
1552     towerbranch->SetAddress(TowerRecPointsRef(fRecPointsTitle)) ;
1553     towerbranch->GetEntry(0) ;
1554
1555     preshowerbranch->SetAddress(PreShowerRecPointsRef(fRecPointsTitle)) ;
1556     preshowerbranch->GetEntry(0) ;
1557
1558     if(!Clusterizer(fRecPointsTitle) )
1559       PostClusterizer(fRecPointsTitle) ;
1560
1561     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1562     clusterizerbranch->GetEntry(0) ;
1563   }
1564
1565   if(gAlice->TreeR()!=treeR)
1566     treeR->Delete();
1567   return 0 ;
1568 }
1569
1570 //____________________________________________________________________________
1571
1572 Int_t AliEMCALGetter::ReadTreeS(const Int_t event)
1573 {
1574   // Reads the SDigits treeS from all files
1575   // Files, which should be opened are listed in emcalF
1576   // So, first get list of files
1577
1578   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
1579
1580   if (!emcalF)
1581     emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
1582
1583   TCollection * folderslist = emcalF->GetListOfFolders() ;
1584
1585   // Now iterate over the list of files and read TreeS into Whiteboard
1586
1587   TIter next(folderslist) ;
1588   TFolder * folder = 0 ;
1589   TFile * file;
1590   TTree * treeS = 0;
1591
1592   while ( (folder = static_cast<TFolder*>(next())) ) {
1593     TString fileName("") ;
1594     if(fToSplit)
1595       fileName = folder->GetTitle() ;
1596     else
1597       fileName = folder->GetName() ;
1598
1599     fileName.ReplaceAll("_","/") ;
1600     file = static_cast<TFile*>(gROOT->GetFile(fileName));
1601
1602     if(!file)
1603       file = TFile::Open(fileName) ;
1604
1605     // Get SDigits Tree header from file
1606
1607     TString treeName("TreeS") ;
1608     treeName += event ;
1609     treeS = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1610
1611     if(!treeS){ // TreeS not found in header file
1612       if (fDebug)
1613         Warning("ReadTreeS", "-> Cannot find TreeS in %s", fileName.Data());
1614       return 1;
1615     }
1616
1617     //set address of the SDigits and SDigitizer
1618
1619     TBranch   * sdigitsBranch    = 0;
1620     TBranch   * sdigitizerBranch = 0;
1621     TBranch   * branch           = 0 ;
1622     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
1623     TIter next(lob) ;
1624
1625     Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ;
1626
1627     while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !sdigitizerfound) ) {
1628       if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1629         emcalfound = kTRUE ;
1630         sdigitsBranch = branch ;
1631       }
1632       else if ( (strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) &&
1633                 (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1634         sdigitizerfound = kTRUE ;
1635         sdigitizerBranch = branch ;
1636       }
1637     }
1638     if ( !emcalfound || !sdigitizerfound ) {
1639       if (fDebug)
1640         Warning("ReadSDigits", "-> Digits and/or Digitizer branch with name %s not found", GetName());
1641       return 2;
1642     }
1643
1644     if ( !folder->FindObject(fSDigitsTitle) )
1645       PostSDigits(fSDigitsTitle,folder->GetName()) ;
1646
1647     ((TClonesArray*) (*SDigitsRef(fSDigitsTitle,folder->GetName())))->Clear() ;
1648
1649     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
1650     sdigitsBranch->GetEntry(0) ;
1651
1652     TString sdname(fSDigitsTitle) ;
1653     sdname+=":" ;
1654     sdname+=folder->GetName() ;
1655
1656     if(!SDigitizer(sdname) )
1657       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
1658
1659     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1660     sdigitizerBranch->GetEntry(0) ;
1661
1662     if(gAlice->TreeS()!=treeS)
1663       treeS->Delete();
1664   }
1665    return 0 ;
1666 }
1667
1668 //____________________________________________________________________________
1669
1670 void AliEMCALGetter::ReadTreeS(TTree * treeS, Int_t input)
1671 {
1672   // Read the summable digits fron treeS()
1673
1674   TString filename("mergefile") ;
1675   filename+= input ;
1676
1677   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
1678   if ( !emcalFolder ) {
1679     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
1680   }
1681
1682   TFolder * folder=(TFolder*)emcalFolder->FindObject(filename) ;
1683
1684   //set address of the SDigits and SDigitizer
1685
1686   TBranch   * sdigitsBranch    = 0;
1687   TBranch   * sdigitizerBranch = 0;
1688   TBranch   * branch           = 0 ;
1689   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
1690   TIter next(lob) ;
1691
1692   Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ;
1693
1694   while ( (branch = (TBranch*)next()) && (!emcalfound || !sdigitizerfound) ) {
1695     if ( strcmp(branch->GetName(), "EMCAL")==0) {
1696       emcalfound = kTRUE ;
1697       sdigitsBranch = branch ;
1698     }
1699     else if ( strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) {
1700       sdigitizerfound = kTRUE ;
1701       sdigitizerBranch = branch ;
1702     }
1703   }
1704
1705   if ( !emcalfound || !sdigitizerfound ) {
1706     if (fDebug)
1707       Warning("ReadTreeS", "-> Digits and/or Digitizer branch not found");
1708     return ;
1709   }
1710
1711   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
1712     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
1713
1714   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
1715   sdigitsBranch->GetEntry(0) ;
1716
1717   TString sdname(sdigitsBranch->GetTitle()) ;
1718   sdname+=":" ;
1719   sdname+=filename ;
1720
1721   if(!SDigitizer(sdigitsBranch->GetTitle()) )
1722     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
1723
1724   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1725   sdigitizerBranch->GetEntry(0) ;
1726
1727   if(gAlice->TreeS()!=treeS)
1728     treeS->Delete();
1729 }
1730
1731 //____________________________________________________________________________
1732
1733 void AliEMCALGetter::ReadPrimaries()
1734 {
1735
1736   // Reads specific branches of primaries
1737
1738   TClonesArray * ar = 0  ;
1739
1740   if(! (ar = Primaries()) ) {
1741     PostPrimaries() ;
1742     ar = Primaries() ;
1743   }
1744
1745   ar->Delete() ;
1746
1747   if (TreeK(fHeaderFile)) { // treeK found in header file
1748     if (fDebug)
1749       Info("ReadPrimaries", "-> TreeK found in %s", fHeaderFile.Data());
1750     fNPrimaries = gAlice->GetNtrack() ;
1751   }
1752   else { // treeK not found in header file
1753     Error("ReadPrimaries", "-> TreeK not  found ");
1754     return ;
1755   }
1756
1757   Int_t index = 0 ;
1758
1759   for (index = 0 ; index < fNPrimaries; index++) {
1760     new ((*ar)[index]) TParticle(*(Primary(index)));
1761   }
1762 }
1763
1764 //____________________________________________________________________________
1765
1766 void AliEMCALGetter::Event(const Int_t event, const char* opt)
1767 {
1768   // Reads the content of all Tree's S, D and R
1769
1770   if (event >= gAlice->TreeE()->GetEntries() ) {
1771     Error("Event", "-> %d not found in TreeE!", event);
1772     return ;
1773   }
1774
1775   Bool_t any = kFALSE ;
1776
1777   if (strstr(opt,"A") ) // do not check the title of the branches
1778     any = kTRUE;
1779
1780   gAlice->GetEvent(event) ;
1781
1782   if( strstr(opt,"R") )
1783     ReadTreeR(event) ;
1784
1785   if( strstr(opt,"D") )
1786     ReadTreeD(event) ;
1787
1788   if(strstr(opt,"S") )
1789     ReadTreeS(event) ;
1790
1791   if(strstr(opt,"H") )
1792     ReadTreeH() ;
1793
1794   if( strstr(opt,"Q") )
1795     ReadTreeQA() ;
1796
1797   if( strstr(opt,"P") )
1798     ReadPrimaries() ;
1799 }
1800
1801 //____________________________________________________________________________
1802
1803 TObject * AliEMCALGetter::ReturnO(TString what, TString name, TString file) const
1804 {
1805   // get the object named "what" from the folder
1806   // folders are named like //Folders
1807
1808   if ( file.IsNull() )
1809     file = fHeaderFile ;
1810
1811   TFolder * folder = 0 ;
1812   TObject * emcalO  = 0 ;
1813
1814   if ( what.CompareTo("Primaries") == 0 ) {
1815     folder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
1816     if (folder)
1817       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Primaries")) ;
1818     else
1819       return 0 ;
1820   }
1821   else if ( what.CompareTo("Hits") == 0 ) {
1822     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
1823     if (folder)
1824       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;
1825   }
1826   else if ( what.CompareTo("SDigits") == 0 ) {
1827     file.ReplaceAll("/","_") ;
1828     TString path = "EMCAL/" + file  ;
1829     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ;
1830     if (folder) {
1831       if (name.IsNull())
1832         name = fSDigitsTitle ;
1833       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1834     }
1835   }
1836   else if ( what.CompareTo("Digits") == 0 ){
1837     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("EMCAL")) ;
1838     if (folder) {
1839       if (name.IsNull())
1840         name = fDigitsTitle ;
1841       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1842     }
1843   }
1844   else if ( what.CompareTo("TowerRecPoints") == 0 ) {
1845     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ;
1846     if (folder) {
1847       if (name.IsNull())
1848         name = fRecPointsTitle ;
1849       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1850     }
1851   }
1852   else if ( what.CompareTo("PreShowerRecPoints") == 0 ) {
1853     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ;
1854     if (folder) {
1855       if (name.IsNull())
1856         name = fRecPointsTitle ;
1857       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
1858     }
1859   }
1860
1861   if (!emcalO) {
1862     if(fDebug)
1863       Warning("ReturnO", "-> Object %s  not found in %s", what.Data(), folder->GetName());
1864     return 0 ;
1865   }
1866
1867   return emcalO ;
1868 }
1869
1870 //____________________________________________________________________________
1871
1872 const TTask * AliEMCALGetter::ReturnT(TString what, TString name) const
1873 {
1874   // get the TTask named "what" from the folder
1875   // folders are named like //Folders/Tasks/what/EMCAL/name
1876
1877   TString search(what) ;
1878   if ( what.CompareTo("Clusterizer") == 0 )
1879     search = "Reconstructioner" ;
1880   else if ( what.CompareTo("TrackSegmentMaker") == 0 )
1881     search = "Reconstructioner" ;
1882   else if ( what.CompareTo("PID") == 0 )
1883     search = "Reconstructioner" ;
1884   else if ( what.CompareTo("QATasks") == 0 )
1885     search = "QA" ;
1886
1887   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ;
1888
1889   if (!tasks) {
1890     Error("AliReturnT", "-> Task %s not found!", what.Data());
1891     return 0 ;
1892   }
1893
1894   TTask * emcalT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ;
1895
1896   if (!emcalT) {
1897     Error("ReturnT", "-> Task %s/EMCAL not found!", what.Data());
1898     return 0 ;
1899   }
1900
1901   TList * list = emcalT->GetListOfTasks() ;
1902
1903   if (what.CompareTo("SDigitizer") == 0) {
1904     if ( name.IsNull() )
1905       name =  fSDigitsTitle ;
1906   }
1907   else  if (what.CompareTo("Digitizer") == 0){
1908     if ( name.IsNull() )
1909       name =  fDigitsTitle ;
1910   }
1911   else  if (what.CompareTo("Clusterizer") == 0){
1912     if ( name.IsNull() )
1913       name =  fRecPointsTitle ;
1914     name.Append(":clu") ;
1915   }
1916
1917   TIter it(list) ;
1918   TTask * task = 0 ;
1919
1920   while((task = static_cast<TTask *>(it.Next()) )){
1921     TString taskname(task->GetName()) ;
1922     if(taskname.BeginsWith(name)){
1923     return task ;}
1924   }
1925
1926   if(fDebug)
1927     Warning("ReturnT", "-> Task %s/%s not found!", search.Data(), name.Data());
1928   return 0 ;
1929 }
1930
1931 //____________________________________________________________________________
1932
1933 void AliEMCALGetter::RemoveTask(TString opt, TString name) const
1934
1935 {
1936   // remove a task from the folder
1937   // path is fTasksFolder/SDigitizer/EMCAL/name
1938
1939   TTask * task  = 0 ;
1940   TTask * emcal = 0 ;
1941   TList * lofTasks = 0 ;
1942
1943   if (opt == "S") { // SDigitizer
1944     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
1945     if (!task)
1946       return ;
1947   }
1948   else if (opt == "D") { // Digitizer
1949     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
1950     if (!task)
1951       return ;
1952   }
1953   else if (opt == "C") { // Clusterizer
1954     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
1955     if (!task)
1956       return ;
1957   }
1958   else {
1959     Warning("RemoveTask", "-> Unknown option %s");
1960     return ;
1961   }
1962
1963   emcal =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
1964
1965   if (!emcal)
1966     return ;
1967
1968   lofTasks = emcal->GetListOfTasks() ;
1969
1970   if (!lofTasks)
1971     return ;
1972
1973   TObject * obj = lofTasks->FindObject(name) ;
1974   if (obj)
1975
1976     lofTasks->Remove(obj) ;
1977 }
1978
1979 //____________________________________________________________________________
1980
1981 void AliEMCALGetter::RemoveObjects(TString opt, TString name) const
1982 {
1983   // remove SDigits from the folder
1984   // path is fSDigitsFolder/fHeaderFileName/name
1985
1986   TFolder * emcal     = 0 ;
1987   TFolder * emcalmain = 0 ;
1988
1989   if (opt == "H") { // Hits
1990     emcal = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
1991     if (!emcal)
1992       return ;
1993     name = "Hits" ;
1994   }
1995   else if ( opt == "S") { // SDigits
1996     emcalmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
1997     if (!emcalmain)
1998       return ;
1999     emcal = dynamic_cast<TFolder*>(emcalmain->FindObject(fHeaderFile)) ;
2000     if (!emcal)
2001       return ;
2002   }
2003   else if (opt == "D") { // Digits
2004     emcal = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
2005     if (!emcal)
2006       return ;
2007   }
2008   else if (opt == "RT") { // Tower RecPoints
2009     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ;
2010     if (!emcal)
2011       return ;
2012   }
2013   else if (opt == "RP") { // Preshower RecPoints
2014     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ;
2015     if (!emcal)
2016       return ;
2017   }
2018   else if (opt == "T") { // TrackSegments
2019     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ;
2020     if (!emcal)
2021       return ;
2022   }
2023   else if (opt == "P") { // RecParticles
2024     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/RecParticles")) ;
2025     if (!emcal)
2026       return ;
2027   }
2028   else {
2029     Warning("RemoveObjects", "-> Unknown option %s", opt.Data());
2030     return ;
2031   }
2032
2033   TObjArray * ar  = dynamic_cast<TObjArray*>(emcal->FindObject(name)) ;
2034
2035   if (ar) {
2036     emcal->Remove(ar) ;
2037     ar->Delete() ;
2038     delete ar ;
2039   }
2040
2041   if (opt == "S")
2042     emcalmain->Remove(emcal) ;
2043 }
2044
2045 //____________________________________________________________________________
2046
2047 void AliEMCALGetter::RemoveSDigits() const
2048 {
2049   TFolder * emcal= dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
2050
2051   if (!emcal)
2052     return ;
2053
2054   emcal->SetOwner() ;
2055   emcal->Clear() ;
2056 }
2057
2058 //____________________________________________________________________________
2059
2060 void AliEMCALGetter::CleanWhiteBoard(void){
2061
2062   TFolder * emcalmain = 0 ;
2063   TFolder * emcal ;
2064   TObjArray * ar ;
2065   TList * lofTasks = 0 ;
2066   TTask * task = 0 ;
2067   TTask * emcalt = 0 ;
2068
2069   // Hits
2070
2071   emcal = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
2072
2073   if (emcal){
2074     TObjArray * ar  = dynamic_cast<TObjArray*>(emcal->FindObject("Hits")) ;
2075     if (ar) {
2076       emcal->Remove(ar) ;
2077       ar->Delete() ;
2078       delete ar ;
2079     }
2080   }
2081
2082   // SDigits
2083
2084   emcalmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
2085
2086   if (emcalmain){
2087     emcal = dynamic_cast<TFolder*>(emcalmain->FindObject(fHeaderFile)) ;
2088     if (emcal) {
2089       ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fSDigitsTitle)) ;
2090       if (ar) {
2091         emcal->Remove(ar) ;
2092         ar->Delete() ;
2093         delete ar ;
2094       }
2095     }
2096     emcalmain->Remove(emcal) ;
2097   }
2098
2099   // Digits
2100
2101   emcal = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
2102
2103   if (emcal){
2104     ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fDigitsTitle)) ;
2105     if (ar) {
2106       emcal->Remove(ar) ;
2107       ar->Delete() ;
2108       delete ar ;
2109     }
2110   }
2111
2112   // TowerRecPoints
2113
2114   emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ;
2115
2116   if (emcal){
2117     ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fRecPointsTitle)) ;
2118     if (ar) {
2119       emcal->Remove(ar) ;
2120       ar->Delete() ;
2121       delete ar ;
2122     }
2123   }
2124
2125   // PreShowerRecPoints
2126
2127   emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ;
2128
2129   if (emcal){
2130     ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fRecPointsTitle)) ;
2131     if (ar) {
2132       emcal->Remove(ar) ;
2133       ar->Delete() ;
2134       delete ar ;
2135     }
2136   }
2137
2138   // TrackSegments
2139
2140   emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ;
2141
2142   if (emcal) {
2143     ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fTrackSegmentsTitle)) ;
2144     if (ar) {
2145       emcal->Remove(ar) ;
2146       ar->Delete() ;
2147       delete ar ;
2148     }
2149   }
2150
2151   // RecParticles
2152
2153   emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/RecParticles")) ;
2154
2155   if (emcal){
2156     ar  = dynamic_cast<TObjArray*>(emcal->FindObject(fRecParticlesTitle)) ;
2157     if (ar) {
2158       emcal->Remove(ar) ;
2159       ar->Delete() ;
2160       delete ar ;
2161     }
2162   }
2163
2164   //---- Now Tasks -----------
2165
2166   TObject * obj ;
2167   TString sdname(fSDigitsTitle);
2168
2169   // Digitizer
2170
2171   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2172
2173   if (task){
2174     emcalt =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
2175     if (emcalt){
2176       lofTasks = emcalt->GetListOfTasks() ;
2177       if (lofTasks){
2178         obj = lofTasks->FindObject(sdname.Data()) ;
2179         if (obj)
2180           lofTasks->Remove(obj) ;
2181       }
2182     }
2183   }
2184
2185   sdname.Append(":") ;
2186
2187   // Clusterizer, TrackSegmentMaker, PID
2188
2189   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2190
2191   if (task){
2192     emcalt =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
2193     if (emcalt){
2194       lofTasks = emcalt->GetListOfTasks() ;
2195       TIter next(lofTasks);
2196       while((obj=next())){
2197         TString oname(obj->GetName()) ;
2198         if (oname.BeginsWith(sdname)){
2199           lofTasks->Remove(obj) ;
2200         }
2201       }
2202     }
2203   }
2204
2205   // SDigitizer
2206
2207   sdname.Append(fHeaderFile) ;
2208   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2209
2210   if (task) {
2211     emcalt =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
2212     if (emcalt){
2213       lofTasks = emcalt->GetListOfTasks() ;
2214       if (lofTasks){
2215         obj = lofTasks->FindObject(sdname.Data()) ;
2216         if (obj)
2217           lofTasks->Remove(obj) ;
2218       }
2219     }
2220   }
2221 }
2222
2223 //____________________________________________________________________________
2224
2225 void AliEMCALGetter::SetTitle(const char * branchTitle )
2226
2227 {
2228   fBranchTitle        = branchTitle ;
2229   fSDigitsTitle       = branchTitle ;
2230   fDigitsTitle        = branchTitle ;
2231   fRecPointsTitle     = branchTitle ;
2232   fRecParticlesTitle  = branchTitle ;
2233   fTrackSegmentsTitle = branchTitle ;
2234
2235   if(fToSplit){
2236
2237     //First - extract full path if necessary
2238
2239     TString sFileName(fHeaderFile) ;
2240     Ssiz_t islash = sFileName.Last('/') ;
2241
2242     if(islash<sFileName.Length())
2243       sFileName.Remove(islash+1,sFileName.Length()) ;
2244     else
2245       sFileName="" ;
2246
2247     //Now construct file names
2248
2249     fSDigitsFileName       = sFileName ;
2250     fDigitsFileName        = sFileName ;
2251     fRecPointsFileName     = sFileName ;
2252     fRecParticlesFileName  = sFileName ;
2253     fTrackSegmentsFileName = sFileName ;
2254     fSDigitsFileName      += "EMCAL.SDigits." ;
2255     fDigitsFileName       += "EMCAL.Digits." ;
2256     fRecPointsFileName    += "EMCAL.RecData." ;
2257     fTrackSegmentsFileName+= "EMCAL.RecData." ;
2258     fRecParticlesFileName += "EMCAL.RecData." ;
2259
2260     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
2261       fSDigitsFileName      += fBranchTitle ;
2262       fSDigitsFileName      += "." ;
2263       fDigitsFileName       += fBranchTitle ;
2264       fDigitsFileName       += "." ;
2265       fRecPointsFileName    += fBranchTitle ;
2266       fRecPointsFileName    += "." ;
2267       fRecParticlesFileName += fBranchTitle ;
2268       fRecParticlesFileName += "." ;
2269       fTrackSegmentsFileName+= fBranchTitle ;
2270       fTrackSegmentsFileName+= "." ;
2271     }
2272
2273     fSDigitsFileName      += "root" ;
2274     fDigitsFileName       += "root" ;
2275     fRecPointsFileName    += "root" ;
2276     fRecParticlesFileName += "root" ;
2277     fTrackSegmentsFileName+= "root" ;
2278   }
2279   else{
2280     fSDigitsFileName       = "" ;
2281     fDigitsFileName        = "" ;
2282     fRecPointsFileName     = "" ;
2283     fRecParticlesFileName  = "" ;
2284     fTrackSegmentsFileName = "" ;
2285   }
2286
2287   TFolder * emcalFolder ;
2288   emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
2289
2290   if ( !emcalFolder )
2291     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ;
2292
2293   emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
2294
2295   if ( !emcalFolder )
2296     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
2297
2298   //Make folder for SDigits
2299
2300   TString subdir(fHeaderFile) ;
2301   subdir.ReplaceAll("/","_") ;
2302
2303   emcalFolder->AddFolder(subdir, fSDigitsFileName.Data());
2304   emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
2305
2306   if ( !emcalFolder )
2307     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;
2308
2309   emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ;
2310
2311   if ( !emcalFolder )
2312     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;
2313 }
2314
2315 //____________________________________________________________________________
2316
2317 void AliEMCALGetter::CloseSplitFiles(void){
2318
2319   TFile * file ;
2320   file = static_cast<TFile*>(gROOT->GetFile(fSDigitsFileName.Data() ) ) ;
2321
2322   if(file)
2323     file->Close() ;
2324
2325   file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName.Data() ) ) ;
2326
2327   if(file)
2328     file->Close() ;
2329
2330   file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName.Data() ) ) ;
2331
2332   if(file)
2333     file->Close() ;
2334
2335   file = static_cast<TFile*>(gROOT->GetFile(fTrackSegmentsFileName.Data() ) ) ;
2336
2337   if(file)
2338     file->Close() ;
2339
2340   file = static_cast<TFile*>(gROOT->GetFile(fRecParticlesFileName.Data() ) ) ;
2341
2342   if(file)
2343     file->Close() ;
2344 }
2345
2346
2347
2348
2349
2350