EMCAL/Getter.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id:  */
  17
  18 /* $Log:
  19 */
  20
  21 //_________________________________________________________________________
  22 //  A singleton. This class should be used in the analysis stage to get
  23 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
  24 //  instead of directly reading them from galice.root file. This container
  25 //  ensures, that one reads Digits, made of these particular digits, RecPoints,
  26 //  made of these particular RecPoints, TrackSegments and RecParticles.
  27 //  This becomes non trivial if there are several identical branches, produced with
  28 //  different set of parameters. Currently This class only Retrieves Hits, Digits, and SDigits.
  29 //
  30 //  An example of how to use (see also class AliEMCALAnalyser):
  31 //  AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ;
  32 //     ................
  33 //  please->GetEvent(event) ;    // reads new event from galice.root
  34 //
  35 //*-- Author: Sahal Yacoob (LBL)
  36 // based on : AliPHOSGetter
  37 //////////////////////////////////////////////////////////////////////////////
  38
  39
  40 // --- ROOT system ---
  41
  42 #include "TFile.h"
  43 #include "TTree.h"
  44 #include "TROOT.h"
  45 #include "TObjString.h"
  46 #include "TFolder.h"
  47
  48 // --- Standard library ---
  49 #include <iostream.h>
  50
  51 // --- AliRoot header files ---
  52
  53 #include "AliRun.h"
  54 #include "AliConfig.h"
  55 #include "AliEMCALGetter.h"
  56 #include "AliEMCALv1.h"
  57 #include "AliEMCALDigitizer.h"
  58 #include "AliEMCALSDigitizer.h"
  59 #include "AliEMCALGeometry.h"
  60
  61 ClassImp(AliEMCALGetter)
  62
  63   AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ;
  64
  65 //____________________________________________________________________________
  66 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle )
  67 {
  68   //Initialize  all lists
  69
  70   fHeaderFile         = headerFile ;
  71   fBranchTitle        = branchTitle ;
  72   fSDigitsTitle       = branchTitle ;
  73   fDigitsTitle        = branchTitle ;
  74
  75   fPrimaries = new TObjArray(1) ;
  76   fModuleFolder  = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules"));
  77   fHitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits"));
  78   fSDigitsFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits"));
  79   fDigitsFolder  = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data"));
  80   fTasksFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ;
  81
  82   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
  83
  84     //open headers file
  85     TFile * file = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
  86
  87     if(file == 0){    //if file was not opened yet, read gAlice
  88       if(fHeaderFile.Contains("rfio")) // if we read file using HPSS
  89         file =  TFile::Open(fHeaderFile.Data(),"update") ;
  90       else
  91         file = new TFile(fHeaderFile.Data(),"update") ;
  92
  93       if (!file->IsOpen()) {
  94         cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot open " << fHeaderFile.Data() << endl ;
  95         abort() ;
  96       }
  97
  98       gAlice = static_cast<AliRun *>(file->Get("gAlice")) ;
  99
 100       if (!gAlice) {
 101         cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ;
 102         abort() ;
 103       }
 104       if (!EMCAL()) {
 105           cout << "INFO: AliEMCALGetter -> Posting EMCAL to Folders" << endl ;
 106         AliConfig * conf = AliConfig::Instance() ;
 107         conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ;
 108         conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
 109      }
 110     }
 111
 112   }
 113 }
 114 //____________________________________________________________________________
 115 AliEMCALGetter::~AliEMCALGetter(){
 116
 117 }
 118
 119 //____________________________________________________________________________
 120 void AliEMCALGetter::CreateWhiteBoard() const
 121 {
 122
 123 }
 124
 125 //____________________________________________________________________________
 126 AliEMCALGetter * AliEMCALGetter::GetInstance()
 127 {
 128   // Returns the pointer of the unique instance already defined
 129
 130   AliEMCALGetter * rv = 0 ;
 131   if ( fgObjGetter )
 132     rv = fgObjGetter ;
 133   else
 134     cout << "AliEMCALGetter::GetInstance ERROR: not yet initialized" << endl ;
 135
 136   return rv ;
 137 }
 138
 139 //____________________________________________________________________________
 140 AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
 141                                            const char* branchTitle)
 142 {
 143   // Creates and returns the pointer of the unique instance
 144   // Must be called only when the environment has changed
 145
 146   if ( fgObjGetter )
 147     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) &&
 148        (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0))
 149       return fgObjGetter ;
 150     else
 151       fgObjGetter->~AliEMCALGetter() ;  // delete it if already exists another version
 152
 153   fgObjGetter = new AliEMCALGetter(headerFile,branchTitle) ;
 154
 155   // Posts a few item to the white board (folders)
 156   // fgObjGetter->CreateWhiteBoard() ;
 157
 158   return fgObjGetter ;
 159
 160 }
 161
 162 //____________________________________________________________________________
 163 const AliEMCALv0 * AliEMCALGetter::EMCAL()
 164 {
 165   // returns the EMCAL object
 166   //AliEMCALv0 * emcal = dynamic_cast<AliEMCALv0 *>(gAlice->GetDetector("EMCAL")) ;
 167   AliEMCALv0 * emcal = dynamic_cast<AliEMCALv1 *>(fModuleFolder->FindObject("EMCAL")) ;
 168   if (!emcal)
 169       cout << "WARNING: AliEMCALGetter::EMCAL -> EMCAL module not found in Folders" << endl ;
 170   return emcal ;
 171 }
 172
 173 //____________________________________________________________________________
 174 const AliEMCALGeometry * AliEMCALGetter::EMCALGeometry()
 175 {
 176   AliEMCALGeometry * rv = 0 ;
 177   if (EMCAL() )
 178    rv =  EMCAL()->GetGeometry() ;
 179   return rv ;
 180 }
 181
 182 //____________________________________________________________________________
 183 Bool_t AliEMCALGetter::PostHits(void) const
 184 {  //------- Hits ----------------------
 185
 186   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
 187
 188   TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
 189   if ( !emcalFolder ) {
 190       cout << "WARNING: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;
 191       cout << "INFO:    AliEMCALGetter::Post H -> Adding Folder //" << fHitsFolder << "/EMCAL/"  << endl;
 192     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ;
 193   }
 194   TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
 195   hits->SetName("Hits") ;
 196   emcalFolder->Add(hits) ;
 197
 198   return kTRUE;
 199 }
 200
 201 //____________________________________________________________________________
 202 void * AliEMCALGetter::HitsRef(void) const
 203 {  //------- Hits ----------------------
 204
 205
 206   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
 207   if ( !fHitsFolder ) {
 208     cerr << "ERROR: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << " not found!" << endl;
 209     return 0;
 210   }
 211
 212   TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
 213   if ( !emcalFolder ) {
 214     cerr << "ERROR: AliEMCALGetter::Post HRef -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;
 215     return 0;
 216   }
 217
 218   TObject * h = emcalFolder->FindObject("Hits") ;
 219   if(!h) {
 220     cerr << "ERROR: AliEMCALGetter::HRef -> " << emcalFolder->GetName() << "/Hits not found !" << endl ;
 221     return 0 ;
 222   }
 223   else
 224     return static_cast<void *>(emcalFolder->GetListOfFolders()->GetObjectRef(h)) ;
 225 }
 226
 227 //____________________________________________________________________________
 228 Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const
 229 {  //---------- SDigits -------------------------
 230
 231
 232   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
 233   // because you can have sdigits from several hit files for mixing
 234
 235   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
 236   if ( !emcalFolder ) {
 237       cout << "WARNING: AliEMCALGetter::Post S -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
 238       cout << "INFO:    AliEMCALGetter::Post S -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl;
 239     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
 240   }
 241   TString subdir(headerFile) ;
 242   TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ;
 243   if ( !emcalSubFolder )
 244     emcalSubFolder = emcalFolder->AddFolder(subdir, "");
 245
 246   TObject * sd  = emcalSubFolder->FindObject(name);
 247   if ( sd ) {
 248       cerr <<"INFO: AliEMCALGetter::Post S -> Folder " << subdir
 249            << " already exists!" << endl ;
 250   }else{
 251     TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1000) ;
 252     sdigits->SetName(name) ;
 253     emcalSubFolder->Add(sdigits) ;
 254   }
 255
 256   return kTRUE;
 257 }
 258 //____________________________________________________________________________
 259 void * AliEMCALGetter::SDigitsRef(const char * name, const char * file) const
 260 {  //------- SDigits ----------------------
 261
 262   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
 263
 264   if ( !fSDigitsFolder ) {
 265     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << " not found!" << endl;
 266     return 0;
 267   }
 268
 269   TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
 270   if ( !emcalFolder ) {
 271     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
 272     return 0;
 273   }
 274
 275   TFolder * emcalSubFolder = 0 ;
 276   if(file)
 277     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
 278   else
 279     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
 280
 281   if(!emcalSubFolder) {
 282     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //Folders/RunMC/Event/Data/EMCAL/" << file << "not found!" << endl;
 283     return 0;
 284   }
 285
 286   TObject * dis = emcalSubFolder->FindObject(name) ;
 287   if(!dis)
 288     return 0 ;
 289   else
 290     return static_cast<void *>(emcalSubFolder->GetListOfFolders()->GetObjectRef(dis)) ;
 291
 292 }
 293
 294 //____________________________________________________________________________
 295 Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const
 296 {  //---------- SDigitizer -------------------------
 297
 298   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 299
 300
 301   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 302
 303   if ( !sd ) {
 304     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 305     return kFALSE ;
 306   }
 307   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 308   if ( !emcal )  {
 309       cout <<"WARNING: AliEMCALGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;
 310       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL/" << endl;
 311     emcal = new TTask("EMCAL", "") ;
 312     sd->Add(emcal) ;
 313   }
 314   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() ));
 315   if (emcalsd) {
 316       cout << "INFO: AliEMCALGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ;
 317     emcal->GetListOfTasks()->Remove(emcalsd) ;
 318   }
 319   emcal->Add(sdigitizer) ;
 320   return kTRUE;
 321
 322 }
 323
 324 //____________________________________________________________________________
 325 void * AliEMCALGetter::SDigitizerRef(const char * name) const
 326 {
 327
 328   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 329   if ( !sd ) {
 330     cerr << "ERROR: AliEMCALGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 331     abort();
 332   }
 333
 334   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 335   if ( !emcal )  {
 336     cerr <<"ERROR: AliEMCALGetter::Post SerRef ->  //" << fTasksFolder << "/SDigitizer/EMCAL not found!" << endl;
 337     abort();
 338   }
 339
 340   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ;
 341
 342   return static_cast<void *>(emcal->GetListOfTasks()->GetObjectRef(task)) ;
 343
 344 }
 345
 346 //____________________________________________________________________________
 347 Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const
 348 {  //---------- SDigitizer -------------------------
 349
 350  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 351
 352
 353   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
 354   if ( !sd ) {
 355     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
 356     return kFALSE ;
 357   }
 358
 359   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 360   if ( !emcal )  {
 361       cout <<"WARNING: AliEMCALGetter::Post Ser ->  //" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;
 362       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding  //" << fTasksFolder << "/SDigitizer/EMCAL" << endl;
 363     emcal = new TTask("EMCAL", "") ;
 364     sd->Add(emcal) ;
 365   }
 366
 367   TString sdname(name) ;
 368   sdname.Append(":") ;
 369   sdname.Append(file);
 370   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname ));
 371   if (!emcalsd) {
 372     emcalsd = new AliEMCALSDigitizer() ;
 373     //Note, we can not call constructor with parameters: it will call Getter and scrud up everething
 374     emcalsd->SetName(sdname) ;
 375     emcalsd->SetTitle(file) ;
 376     emcal->Add(emcalsd) ;
 377   }
 378   return kTRUE;
 379
 380 }
 381
 382 //____________________________________________________________________________
 383 Bool_t AliEMCALGetter::PostDigits(const char * name) const
 384 {  //---------- Digits -------------------------
 385
 386   // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name
 387
 388   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
 389
 390   if ( !emcalFolder ) {
 391       cout << "WARNING: AliEMCALGetter::Post D -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
 392       cout << "INFO:    AliEMCALGetter::Post D -> Adding Folder //" << fDigitsFolder << "/EMCAL/" << endl;
 393     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;
 394   }
 395
 396   TObject*  dig = emcalFolder->FindObject( name ) ;
 397   if ( !dig ) {
 398     TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ;
 399     digits->SetName(name) ;
 400     emcalFolder->Add(digits) ;
 401   }
 402   return kTRUE;
 403 }
 404
 405 //____________________________________________________________________________
 406 void * AliEMCALGetter::DigitsRef(const char * name) const
 407 { //------- Digits ----------------------
 408
 409   // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name
 410
 411   if ( !fDigitsFolder ) {
 412     cerr << "ERROR: AliEMCALGetter::Post DRef -> Folder //" << fDigitsFolder << " not found!" << endl;
 413     return 0;
 414   }
 415
 416   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
 417   if ( !emcalFolder ) {
 418     cerr << "ERROR: AliEMCALGetter::DRef -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
 419     return 0;
 420   }
 421
 422   TObject * d = emcalFolder->FindObject(name) ;
 423   if(!d)
 424     return 0 ;
 425   else
 426     return static_cast<void *>(emcalFolder->GetListOfFolders()->GetObjectRef(d)) ;
 427
 428 }
 429
 430 //____________________________________________________________________________
 431 Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const
 432 {  //---------- Digitizer -------------------------
 433
 434   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 435
 436   if ( !sd ) {
 437     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 438     return kFALSE ;
 439   }
 440   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 441   if ( !emcal )  {
 442       cout <<"WARNING: AliEMCALGetter::Post Der ->  //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl;
 443       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
 444     emcal = new TTask("EMCAL", "") ;
 445     sd->Add(emcal) ;
 446   }
 447
 448     AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ;
 449     if (emcald) {
 450       emcald->Delete() ;
 451       emcal->GetListOfTasks()->Remove(emcald) ;
 452     }
 453     emcal->Add(digitizer) ;
 454     return kTRUE;
 455 }
 456
 457 //____________________________________________________________________________
 458 Bool_t AliEMCALGetter::PostDigitizer(const char * name) const
 459 {  //---------- Digitizer -------------------------
 460
 461  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
 462
 463   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 464   if ( !d ) {
 465     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 466     return kFALSE ;
 467   }
 468
 469   TTask * emcal = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("EMCAL")) ;
 470   if ( !emcal )  {
 471       cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl;
 472       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
 473     emcal = new TTask("EMCAL", "") ;
 474     d->Add(emcal) ;
 475 }
 476
 477   AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(name)) ;
 478   if (!emcald) {
 479     emcald = new AliEMCALDigitizer() ;
 480     emcald->SetName(fDigitsTitle) ;
 481     emcald->SetTitle(fHeaderFile) ;
 482     emcal->Add(emcald) ;
 483   }
 484   return kTRUE;
 485 }
 486
 487 //____________________________________________________________________________
 488 void * AliEMCALGetter::DigitizerRef(const char * name) const
 489 {
 490   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
 491   if ( !sd ) {
 492     cerr << "ERROR: AliEMCALGetter::Post DerRef -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
 493     abort();
 494   }
 495
 496   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ;
 497   if ( !emcal )  {
 498     cerr <<"ERROR: AliEMCALGetter::Post DerRef ->  //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
 499     abort();
 500   }
 501
 502   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ;
 503
 504   return static_cast<void *>(emcal->GetListOfTasks()->GetObjectRef(task)) ;
 505
 506 }
 507
 508 //____________________________________________________________________________
 509 const TParticle * AliEMCALGetter::Primary(Int_t index) const
 510 {
 511   // Return primary particle numbered by <index>
 512
 513   if(index < 0)
 514     return 0 ;
 515
 516   Int_t primaryIndex = index % 10000000 ;
 517   Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.)  ;
 518
 519   if ( primaryList > 0  ) {
 520       cout << " Getter does not support currently Mixing of primary " << endl ;
 521       cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
 522     return 0;
 523   }
 524
 525   return gAlice->Particle(primaryIndex) ;
 526
 527 }
 528
 529 //____________________________________________________________________________
 530 void AliEMCALGetter::ReadTreeD()
 531 {
 532   // Read the digit tree gAlice->TreeD()
 533   if(gAlice->TreeD()== 0){
 534     cerr <<   "ERROR: AliEMCALGetter::ReadTreeD: can not read TreeD " << endl ;
 535   return ;
 536   }
 537  cout << "hello" << endl;
 538   TObjArray * lob = static_cast<TObjArray*>(gAlice->TreeD()->GetListOfBranches()) ;
 539   TIter next(lob) ;
 540   TBranch * branch = 0 ;
 541   TBranch * digitsbranch = 0 ;
 542   TBranch * digitizerbranch = 0 ;
 543   Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ;
 544
 545   while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !digitizerfound) ) {
 546     if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
 547       digitsbranch = branch ;
 548       emcalfound = kTRUE ;
 549     }
 550     else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
 551       digitizerbranch = branch ;
 552       digitizerfound = kTRUE ;
 553     }
 554   }
 555
 556   if ( !emcalfound || !digitizerfound ) {
 557       cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name "
 558            << fDigitsTitle << endl ;
 559     return ;
 560   }
 561
 562   //read digits
 563   if(!Digits(fDigitsTitle) )
 564     PostDigits(fDigitsTitle);
 565   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
 566   digitsbranch->GetEntry(0) ;
 567
 568
 569   // read  the Digitizer
 570   if(!Digitizer(fDigitsTitle))
 571     PostDigitizer(fDigitsTitle) ;
 572   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
 573   digitizerbranch->GetEntry(0) ;
 574
 575
 576 }
 577
 578 //____________________________________________________________________________
 579 void AliEMCALGetter::ReadTreeH()
 580 {
 581   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
 582
 583   if(gAlice->TreeH()== 0){
 584     cerr <<   "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
 585     return ;
 586   }
 587
 588   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("EMCAL")) ;
 589   if ( !hitsbranch ) {
 590       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ;
 591     return ;
 592   }
 593   if(!Hits())
 594     PostHits() ;
 595
 596   hitsbranch->SetAddress(HitsRef()) ;
 597
 598   hitsbranch->GetEntry(0) ;
 599
 600 }
 601
 602 //____________________________________________________________________________
 603 void AliEMCALGetter::Track(Int_t itrack)
 604 {
 605   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
 606
 607   if(gAlice->TreeH()== 0){
 608     cerr <<   "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
 609     return ;
 610   }
 611
 612   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
 613   if ( !hitsbranch ) {
 614       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ;
 615     return ;
 616   }
 617   if(!Hits())
 618     PostHits() ;
 619   hitsbranch->SetAddress(HitsRef()) ;
 620   hitsbranch->GetEntry(itrack) ;
 621
 622
 623 }
 624 //____________________________________________________________________________
 625 void AliEMCALGetter::ReadTreeS(Int_t event)
 626 {
 627   // Read the summable digits tree gAlice->TreeS()
 628
 629   // loop over all opened files and read their SDigits to the White Board
 630   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
 631   if (!emcalF)
 632     emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
 633   TCollection * folderslist = emcalF->GetListOfFolders() ;
 634
 635   //Add current file to list if it is not there yet
 636   if ( (fHeaderFile != "aliroot") && ( !folderslist->Contains(fHeaderFile) ) ){
 637     emcalF->AddFolder(fHeaderFile, "");
 638   }
 639
 640   TIter next(folderslist) ;
 641   TFolder * folder = 0 ;
 642   TFile * file;
 643   TTree * treeS = 0;
 644   while ( (folder = static_cast<TFolder*>(next())) ) {
 645     if(fHeaderFile.CompareTo(folder->GetName()) == 0 )
 646       {treeS=gAlice->TreeS() ;
 647         cout << "ReadTreeS  "<<  gAlice->TreeS()  <<endl ;}
 648     else{
 649      cout << " AliEMCALGetter::ReadTreeS 2 " <<  folder->GetName() << endl ;
 650      file = static_cast<TFile*>(gROOT->GetFile(folder->GetName()));
 651       file->cd() ;
 652
 653       // Get SDigits Tree header from file
 654       TString treeName("TreeS") ;
 655       treeName += event ;
 656       treeS = dynamic_cast<TTree*>(gDirectory->Get(treeName.Data()));
 657     }
 658     if(treeS==0){
 659       cerr << "ERROR: AliEMCALGetter::ReadTreeS There is no SDigit Tree" << endl;
 660       return ;
 661     }
 662
 663     //set address of the SDigits and SDigitizer
 664     TBranch   * sdigitsBranch    = 0;
 665     TBranch   * sdigitizerBranch = 0;
 666     TBranch   * branch           = 0 ;
 667     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
 668     TIter next(lob) ;
 669     Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ;
 670
 671     while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !sdigitizerfound) ) {
 672
 673      if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
 674         emcalfound = kTRUE ;
 675         sdigitsBranch = branch ;
 676        cout << "sdigitsbranch found = " << branch << endl ;
 677        }
 678
 679       else if ( (strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
 680         sdigitizerfound = kTRUE ;
 681         sdigitizerBranch = branch ;
 682        cout << "sdigitizerbranch found = " << branch << endl ;
 683       }
 684     }
 685     if ( !emcalfound || !sdigitizerfound ) {
 686         cout << "WARNING: AliEMCALDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName()
 687              << " not found" << endl ;
 688       return ;
 689     }
 690
 691     if ( !folder->FindObject(fSDigitsTitle) )
 692      { PostSDigits(fSDigitsTitle,folder->GetName()) ;
 693        cout << "Posting SDigits " << endl << endl ;}
 694     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
 695
 696     sdigitsBranch->GetEntry(0) ;
 697
 698     TString sdname(fSDigitsTitle) ;
 699     cout << sdname << endl ;
 700     sdname+=":" ;
 701     sdname+=folder->GetName() ;
 702     if(!SDigitizer(sdname) )
 703       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
 704     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
 705     sdigitizerBranch->GetEntry(0) ;
 706
 707   }
 708
 709   // After SDigits have been read from all files, return to the first one
 710
 711   next.Reset();
 712   folder = static_cast<TFolder*>(next());
 713   if(folder){
 714     file   = static_cast<TFile*>(gROOT->GetFile(folder->GetName()));
 715     file   ->cd() ;
 716   }
 717
 718 }
 719 //____________________________________________________________________________
 720 void AliEMCALGetter::ReadTreeS(TTree * treeS, Int_t input)
 721 {  // Read the summable digits fron treeS()
 722
 723
 724   TString filename("mergefile") ;
 725   filename+= input ;
 726
 727   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
 728   if ( !emcalFolder ) {
 729    emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ;
 730   }
 731   TFolder * folder=(TFolder*)emcalFolder->FindObject(filename) ;
 732   //set address of the SDigits and SDigitizer
 733   TBranch   * sdigitsBranch    = 0;
 734   TBranch   * sdigitizerBranch = 0;
 735   TBranch   * branch           = 0 ;
 736   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
 737   TIter next(lob) ;
 738   Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ;
 739
 740   while ( (branch = (TBranch*)next()) && (!emcalfound || !sdigitizerfound) ) {
 741     if ( strcmp(branch->GetName(), "EMCAL")==0) {
 742       emcalfound = kTRUE ;
 743       sdigitsBranch = branch ;
 744     }
 745
 746     else if ( strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) {
 747       sdigitizerfound = kTRUE ;
 748       sdigitizerBranch = branch ;
 749     }
 750   }
 751   if ( !emcalfound || !sdigitizerfound ) {
 752       cout << "WARNING: AliEMCALGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
 753     return ;
 754   }
 755
 756   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
 757     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
 758
 759   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
 760
 761   TString sdname(sdigitsBranch->GetTitle()) ;
 762   sdname+=":" ;
 763   sdname+=filename ;
 764   if(!SDigitizer(sdigitsBranch->GetTitle()) )
 765     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
 766   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
 767
 768   sdigitsBranch->GetEntry(0) ;
 769   sdigitizerBranch->GetEntry(0) ;
 770
 771 }
 772
 773
 774 //____________________________________________________________________________
 775 void AliEMCALGetter::ReadPrimaries()
 776 {
 777   // Reads specific branches of primaries
 778
 779   fNPrimaries = gAlice->GetNtrack();
 780
 781   //   //Check, is it necessary to open new files
 782   //   TArrayI* events = fDigitizer->GetCurrentEvents() ;
 783   //   TClonesArray * filenames = fDigitizer->GetHeadersFiles() ;
 784 //   Int_t input ;
 785 //   for(input = 0; input < filenames->GetEntriesFast(); input++){
 786
 787 //     TObjString * filename = (TObjString *) filenames->At(input) ;
 788
 789 //     //Test, if this file already open
 790 //     TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ;
 791 //     if(file == 0)
 792 //       file = new TFile( filename->GetString()) ;
 793 //     file->cd() ;
 794
 795 //     // Get Kine Tree from file
 796 // //     char treeName[20];
 797 // //     sprintf(treeName,"TreeK%d",events->At(input));
 798 // //     TTree * treeK = (TTree*)gDirectory->Get(treeName);
 799 // //     if (treeK)
 800 // //       treeK->SetBranchAddress("Particles", &fParticleBuffer);
 801 // //     else
 802 // //       cout << "AliEMCALGetter: cannot find Kine Tree for event:" << events->At(input) << endl;
 803
 804 // //     // Create the particle stack
 805 // //     if(!fParticles) fParticles = new TClonesArray("TParticle",1000);
 806 // //     // Build the pointer list
 807 // //     if(fParticleMap) {     <----
 808 // //       fParticleMap->Clear();
 809 // //       fParticleMap->Expand(treeK->GetEntries());
 810 // //     } else
 811 // //       fParticleMap = new TObjArray(treeK->GetEntries());
 812
 813 //     // From gAlice->Particle(i)
 814
 815
 816 // //   if(!(*fParticleMap)[i]) {
 817 // //     Int_t nentries = fParticles->GetEntries();
 818
 819 // //     // algorithmic way of getting entry index
 820 // //     // (primary particles are filled after secondaries)
 821 // //     Int_t entry;
 822 // //     if (i<fHeader.GetNprimary())
 823 // //       entry = i+fHeader.GetNsecondary();
 824 // //     else
 825 // //       entry = i-fHeader.GetNprimary();
 826
 827 // //     // only check the algorithmic way and give
 828 // //     // the fatal error if it is wrong
 829 // //     if (entry != fParticleFileMap[i]) {
 830 // //       Fatal("Particle",
 831 // //         "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d",
 832 // //   entry, fParticleFileMap[i]);
 833 // //     }
 834
 835 // //     fTreeK->GetEntry(fParticleFileMap[i]);
 836 // //     new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
 837 // //     fParticleMap->AddAt((*fParticles)[nentries],i);
 838 // //   }
 839 // //   return (TParticle *) (*fParticleMap)[i];
 840
 841
 842
 843 //   }
 844
 845
 846 //   //scan over opened files and read corresponding TreeK##
 847
 848   return ;
 849 }
 850 //____________________________________________________________________________
 851 void AliEMCALGetter::Event(const Int_t event, const char* opt)
 852 {
 853   // Reads the content of all Tree's S, D and R
 854
 855   if (event >= gAlice->TreeE()->GetEntries() ) {
 856     cerr << "ERROR: AliEMCALGetter::Event -> " << event << " not found in TreeE!" << endl ;
 857     return ;
 858   }
 859   gAlice->GetEvent(event) ;
 860
 861   if(strstr(opt,"H") )
 862    {cout<<"Reading TreeH" << endl ;
 863    ReadTreeH() ;}
 864
 865   if(strstr(opt,"S") )
 866     { cout << "Reading TreeS" << endl ;
 867     ReadTreeS(event) ;}
 868
 869   if( strstr(opt,"D") )
 870     ReadTreeD() ;
 871
 872   if( strstr(opt,"R") )
 873 //    ReadTreeR() ;
 874
 875   if( strstr(opt,"Q") )
 876 //    ReadTreeQA() ;
 877
 878   if( strstr(opt,"P") )
 879     ReadPrimaries() ;
 880
 881 }
 882
 883 //____________________________________________________________________________
 884 const TObject * AliEMCALGetter::ReturnO(TString what, TString name, TString file) const
 885 {
 886   // get the object named "what" from the folder
 887   // folders are named like //Folders
 888
 889   if ( file.IsNull() )
 890     file = fHeaderFile ;
 891
 892   TFolder * folder = 0 ;
 893   TObject * emcalO  = 0 ;
 894
 895   //  if ( name.IsNull() ) {
 896   if ( what.CompareTo("Hits") == 0 ) {
 897     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
 898     if (folder)
 899       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;
 900   }
 901   else if ( what.CompareTo("SDigits") == 0 ) {
 902     TString path = "EMCAL/" + file  ;
 903     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ;
 904     if (folder) {
 905     cout << "folder found" << endl ;
 906     if (name.IsNull())
 907         name = fSDigitsTitle ;
 908       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
 909     }
 910   }
 911   else if ( what.CompareTo("Digits") == 0 ){
 912     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("EMCAL")) ;
 913     if (folder) {
 914       if (name.IsNull())
 915         name = fDigitsTitle ;
 916       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
 917     }
 918   }
 919   if (!emcalO) {
 920       cerr << "ERROR : AliEMCALGetter::ReturnO -> Object " << what << " not found in " << folder->GetName() << endl ;
 921     return 0 ;
 922   }
 923   return emcalO ;
 924 }
 925
 926 //____________________________________________________________________________
 927 const TTask * AliEMCALGetter::ReturnT(TString what, TString name) const
 928 {
 929   // get the TTask named "what" from the folder
 930   // folders are named like //Folders/Tasks/what/EMCAL/name
 931
 932   TString search(what) ;
 933
 934   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ;
 935
 936   if (!tasks) {
 937     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << " not found!" << endl ;
 938     return 0 ;
 939   }
 940
 941   TTask * emcalT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ;
 942   if (!emcalT) {
 943     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << "/EMCAL not found!" << endl ;
 944     return 0 ;
 945   }
 946
 947   TList * list = emcalT->GetListOfTasks() ;
 948
 949   if (what.CompareTo("SDigitizer") == 0) {
 950     if ( name.IsNull() )
 951       name =  fSDigitsTitle ;
 952   } else  if (what.CompareTo("Digitizer") == 0){
 953     if ( name.IsNull() )
 954       name =  fDigitsTitle ;
 955   }
 956
 957   TIter it(list) ;
 958   TTask * task = 0 ;
 959   while((task = static_cast<TTask *>(it.Next()) )){
 960     TString taskname(task->GetName()) ;
 961     if(taskname.BeginsWith(name))
 962       return task ;
 963   }
 964
 965     cout << "WARNING: AliEMCALGetter::ReturnT -> Task " << search << "/" << name << " not found!" << endl ;
 966   return 0 ;
 967 }