EMCAL/AliEMCALLoader.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 //_________________________________________________________________________
  19 //  A singleton. This class should be used in the analysis stage to get
  20 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
  21 //  instead of directly reading them from galice.root file. This container
  22 //  ensures, that one reads Digits, made of these particular digits, RecPoints,
  23 //  made of these particular RecPoints, TrackSegments and RecParticles.
  24 //  This becomes non trivial if there are several identical branches, produced with
  25 //  different set of parameters.
  26 //
  27 //  An example of how to use (see also class AliEMCALAnalyser):
  28 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
  29 //     AliEMCALRecParticle * part = gime->RecParticle(1) ;
  30 //     ................
  31 //  please->GetEvent(event) ;    // reads new event from galice.root
  32 //
  33 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  34 //*--         Completely redesigned by Dmitri Peressounko March 2001
  35 //
  36 //*-- YS June 2001 : renamed the original AliEMCALIndexToObject and make
  37 //*--         systematic usage of TFolders without changing the interface
  38 //////////////////////////////////////////////////////////////////////////////
  39
  40
  41 // --- ROOT system ---
  42
  43 #include "TTree.h"
  44
  45 // --- Standard library ---
  46
  47 // --- AliRoot header files ---
  48
  49 #include "AliEMCALLoader.h"
  50 #include "AliEMCAL.h"
  51 #include "AliEMCALHit.h"
  52 #include "AliEMCALGetter.h"
  53
  54 ClassImp(AliEMCALLoader)
  55
  56
  57 const TString AliEMCALLoader::fgkHitsName("HITS");//Name for TClonesArray with hits from one event
  58 const TString AliEMCALLoader::fgkSDigitsName("SDIGITS");//Name for TClonesArray
  59 const TString AliEMCALLoader::fgkDigitsName("DIGITS");//Name for TClonesArray
  60 const TString AliEMCALLoader::fgkECARecPointsName("ECARECPOINTS");//Name for TClonesArray
  61 const TString AliEMCALLoader::fgkTracksName("TRACKS");//Name for TClonesArray
  62 const TString AliEMCALLoader::fgkRecParticlesName("RECPARTICLES");//Name for TClonesArray
  63
  64 const TString AliEMCALLoader::fgkECARecPointsBranchName("EMCALECARP");//Name for branch with ECA Reconstructed Points
  65 const TString AliEMCALLoader::fgkTrackSegmentsBranchName("EMCALTS");//Name for branch with TrackSegments
  66 const TString AliEMCALLoader::fgkRecParticlesBranchName("EMCALRP");//Name for branch with Reconstructed Particles
  67
  68 //____________________________________________________________________________
  69 AliEMCALLoader::AliEMCALLoader()
  70 {
  71   fDebug = 0;
  72   fRecParticlesLoaded = kFALSE;
  73 }
  74
  75 //____________________________________________________________________________
  76 AliEMCALLoader::AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername):
  77   AliLoader(detname,eventfoldername)
  78 {
  79   fDebug=0;
  80   fRecParticlesLoaded = kFALSE;
  81 }
  82
  83 //____________________________________________________________________________
  84 AliEMCALLoader::~AliEMCALLoader()
  85 {
  86   //remove and delete arrays
  87   Clean(fgkHitsName);
  88   Clean(fgkSDigitsName);
  89   Clean(fgkDigitsName);
  90   Clean(fgkECARecPointsName);
  91   Clean(fgkTracksName);
  92   Clean(fgkRecParticlesName);
  93   // set to 0x0 the objgetter in AliGetter ... weird isn it !
  94   AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
  95   if (gime)
  96     gime->Reset() ;
  97 }
  98
  99 //____________________________________________________________________________
 100 void AliEMCALLoader::CleanFolders()
 101 {
 102   CleanRecParticles();
 103   AliLoader::CleanFolders();
 104 }
 105
 106 //____________________________________________________________________________
 107 Int_t AliEMCALLoader::SetEvent()
 108 {
 109   //Cleans loaded stuff and and sets Files and Directories
 110   // do not post any data to folder/tasks
 111
 112
 113   Int_t retval = AliLoader::SetEvent();
 114   if (retval)
 115    {
 116      Error("SetEvent","AliLoader::SetEvent returned error");
 117      return retval;
 118    }
 119
 120
 121   if (Hits()) Hits()->Clear();
 122   if (SDigits()) SDigits()->Clear();
 123   if (Digits()) Digits()->Clear();
 124   if (ECARecPoints()) ECARecPoints()->Clear();
 125   if (TrackSegments()) TrackSegments()->Clear();
 126   if (RecParticles()) RecParticles()->Clear();
 127
 128   return 0;
 129 }
 130
 131 //____________________________________________________________________________
 132 Int_t AliEMCALLoader::GetEvent()
 133 {
 134   //Overloads GetEvent method called by AliRunLoader::GetEvent(Int_t) method
 135   //to add Rec Particles specific for EMCAL
 136
 137   //First call the original method to get whatever from std. setup is needed
 138   Int_t retval;
 139
 140   retval = AliLoader::GetEvent();
 141   if (retval)
 142     {
 143       Error("GetEvent","AliLoader::GetEvent returned error");
 144       return retval;
 145     }
 146
 147   if (GetHitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadHits();
 148   if (GetSDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadSDigits();
 149   if (GetDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadDigits();
 150   if (GetRecPointsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecPoints();
 151   if (GetTracksDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadTracks();
 152   if (GetRecParticlesDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecParticles();
 153
 154
 155   //Now, check if RecPart were loaded
 156   return 0;
 157 }
 158
 159 //____________________________________________________________________________
 160 const AliEMCAL * AliEMCALLoader::EMCAL()
 161 {
 162   // returns the EMCAL object
 163   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(GetModulesFolder()->FindObject(fDetectorName));
 164   if ( emcal == 0x0)
 165     if (fDebug)
 166       cout << "WARNING: AliEMCALLoader::EMCAL -> EMCAL module not found in Folders" << endl ;
 167   return emcal ;
 168 }
 169
 170 //____________________________________________________________________________
 171 const AliEMCALGeometry * AliEMCALLoader::EMCALGeometry()
 172 {
 173   // Gets the EMCAL Geometry object
 174   AliEMCALGeometry * rv = 0 ;
 175   if (EMCAL() )
 176     rv =  EMCAL()->GetGeometry();
 177   return rv ;
 178 }
 179
 180 //____________________________________________________________________________
 181 Int_t AliEMCALLoader::LoadHits(Option_t* opt)
 182 {
 183   //------- Hits ----------------------
 184   //Overload (extends) LoadHits implemented in AliLoader
 185   //
 186   Int_t res;
 187
 188   //First call the AliLoader's method to send the TreeH to folder
 189   res = AliLoader::LoadHits(opt);
 190
 191   if (res)
 192    {//oops, error
 193      Error("LoadHits","AliLoader::LoadHits returned error");
 194      return res;
 195    }
 196
 197   //read the data from tree in folder and send it to folder
 198   res = ReadHits();
 199   return 0;
 200 }
 201
 202 //____________________________________________________________________________
 203 Int_t AliEMCALLoader::LoadSDigits(Option_t* opt)
 204 {
 205   // Loads the SDigits array in the folder structure
 206   Int_t res;
 207   //First call the AliLoader's method to send the TreeS to folder
 208   res = AliLoader::LoadSDigits(opt);
 209   if (res)
 210     {//oops, error
 211       Error("PostSDigits","AliLoader::LoadSDigits returned error");
 212       return res;
 213     }
 214   return ReadSDigits();
 215
 216 }
 217
 218 //____________________________________________________________________________
 219 Int_t AliEMCALLoader::LoadDigits(Option_t* opt)
 220 {
 221   // Loads the Digits array in the folder structure
 222
 223   Int_t res;
 224   //First call the AliLoader's method to send the TreeS to folder
 225   res = AliLoader::LoadDigits(opt);
 226   if (res)
 227     {//oops, error
 228       Error("LoadDigits","AliLoader::LoadDigits returned error");
 229       return res;
 230     }
 231   return ReadDigits();
 232 }
 233
 234 //____________________________________________________________________________
 235 Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt)
 236 {
 237   // Loads the RecPoints array in the folder structure
 238   Int_t res;
 239   //First call the AliLoader's method to send the TreeR to folder
 240   res = AliLoader::LoadRecPoints(opt);
 241   if (res)
 242     {//oops, error
 243       Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
 244       return res;
 245     }
 246
 247   TFolder * emcalFolder = GetDetectorDataFolder();
 248   if ( emcalFolder  == 0x0 )
 249     {
 250       Error("LoadRecPoints","Can not get detector data folder");
 251       return 1;
 252     }
 253   return ReadRecPoints();
 254 }
 255
 256 //____________________________________________________________________________
 257 Int_t  AliEMCALLoader::LoadTracks(Option_t* opt)
 258 {
 259   //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
 260   if (GetDebug())
 261     printf("LoadTracks: opt = %s",opt);
 262   if (fTracksLoaded)
 263     {
 264       Warning("LoadTracks","Tracks are already loaded");
 265       return 0;
 266     }
 267   Int_t res;
 268   //First call the AliLoader's method to send the TreeS to folder
 269   if (GetTracksDataLoader()->GetBaseLoader(0)->IsLoaded() == kFALSE)
 270     {//tracks can be loaded by LoadRecPoints
 271       res = AliLoader::LoadTracks(opt);
 272       if (res)
 273         {//oops, error
 274           Error("LoadTracks","AliLoader::LoadTracks returned error");
 275           return res;
 276         }
 277     }
 278   res = ReadTracks();
 279   if (res)
 280     {
 281       Error("LoadTracks","Error occured while reading Tracks");
 282       return res;
 283     }
 284
 285   fTracksLoaded = kTRUE;
 286   return 0;
 287 }
 288
 289 //____________________________________________________________________________
 290 Int_t AliEMCALLoader::LoadRecParticles(Option_t* opt)
 291 {
 292   // Loads the RecParticles array in the folder structure
 293   Int_t res;
 294   //First call the AliLoader's method to send the TreeS to folder
 295   res = AliLoader::LoadRecParticles(opt);
 296   if (res)
 297     {//oops, error
 298       Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
 299       return res;
 300     }
 301
 302   TFolder * emcalFolder = GetDetectorDataFolder();
 303   if ( emcalFolder  == 0x0 )
 304     {
 305       Error("PostDigits","Can not get detector data folder");
 306       return 1;
 307     }
 308   return ReadRecParticles();
 309 }
 310
 311 //____________________________________________________________________________
 312 Int_t AliEMCALLoader::PostHits()
 313 {
 314   Int_t reval = AliLoader::PostHits();
 315   if (reval)
 316     {
 317      Error("PostHits","AliLoader::  returned error");
 318      return reval;
 319     }
 320   return ReadHits();
 321 }
 322
 323 //____________________________________________________________________________
 324 Int_t AliEMCALLoader::PostSDigits()
 325 {
 326   // Posts the SDigits array to the folder structure
 327   Int_t reval = AliLoader::PostSDigits();
 328   if (reval)
 329    {
 330      Error("PostSDigits","AliLoader::PostSDigits  returned error");
 331      return reval;
 332    }
 333   return ReadSDigits();
 334 }
 335
 336 //____________________________________________________________________________
 337 Int_t AliEMCALLoader::PostDigits()
 338 {
 339   // Posts the Digits array to the folder structure
 340   Int_t reval = AliLoader::PostDigits();
 341   if (reval)
 342     {
 343       Error("PostDigits","AliLoader::PostDigits  returned error");
 344       return reval;
 345     }
 346   return ReadDigits();
 347 }
 348
 349 //____________________________________________________________________________
 350 Int_t AliEMCALLoader::PostRecPoints()
 351 {
 352   // Posts the RecPoints array to the folder structure
 353   Int_t reval = AliLoader::PostRecPoints();
 354   if (reval)
 355    {
 356      Error("PostRecPoints","AliLoader::PostRecPoints  returned error");
 357      return reval;
 358    }
 359   return ReadRecPoints();
 360 }
 361
 362 //____________________________________________________________________________
 363 Int_t AliEMCALLoader::PostRecParticles()
 364 {
 365   // Posts the RecParticles array to the folder structure
 366
 367   Int_t reval = AliLoader::PostRecParticles();
 368   if (reval)
 369     {
 370       Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
 371       return reval;
 372     }
 373   return ReadRecParticles();
 374 }
 375
 376 //____________________________________________________________________________
 377 Int_t AliEMCALLoader::PostTracks()
 378 {
 379   // Posts the Tracks array to the folder structure
 380   Int_t reval = AliLoader::PostTracks();
 381   if (reval)
 382     {
 383       Error("PostTracks","AliLoader::PostTracks  returned error");
 384       return reval;
 385     }
 386   return ReadTracks();
 387 }
 388
 389 //____________________________________________________________________________
 390 Int_t AliEMCALLoader::ReadHits()
 391 {
 392   // If there is no Clones Array in folder creates it and sends to folder
 393   // then tries to read
 394   // Reads the first entry of EMCAL branch in hit tree TreeH()
 395   // Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
 396   //
 397   TObject** hitref = HitsRef();
 398   if(hitref == 0x0)
 399     {
 400       MakeHitsArray();
 401      hitref = HitsRef();
 402     }
 403
 404   TClonesArray* hits = dynamic_cast<TClonesArray*>(*hitref);
 405
 406   TTree* treeh = TreeH();
 407
 408   if(treeh == 0)
 409     {
 410       Error("ReadHits"," Cannot read TreeH from folder");
 411       return 1;
 412     }
 413
 414   TBranch * hitsbranch = treeh->GetBranch(fDetectorName);
 415   if (hitsbranch == 0)
 416     {
 417       Error("ReadHits"," Cannot find branch EMCAL");
 418       return 1;
 419     }
 420
 421   if (GetDebug())
 422     printf("ReadHits: Reading Hits");
 423
 424   if (hitsbranch->GetEntries() > 1)
 425     {
 426       TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000);
 427
 428       hitsbranch->SetAddress(&tempo);
 429       Int_t index = 0 ;
 430       Int_t i = 0 ;
 431       for (i = 0 ; i < hitsbranch->GetEntries(); i++)
 432         {
 433           hitsbranch->GetEntry(i) ;
 434           Int_t j = 0 ;
 435           for ( j = 0 ; j < tempo->GetEntries() ; j++)
 436             {
 437               AliEMCALHit* hit = (AliEMCALHit*)tempo->At(j);
 438               new((*hits)[index]) AliEMCALHit( *hit ) ;
 439               index++ ;
 440             }
 441         }
 442       delete tempo;
 443     }
 444   else
 445     {
 446       hitsbranch->SetAddress(hitref);
 447       hitsbranch->GetEntry(0) ;
 448     }
 449
 450   return 0;
 451 }
 452
 453 //____________________________________________________________________________
 454 Int_t AliEMCALLoader::ReadSDigits()
 455 {
 456   // Read the summable digits tree TreeS():
 457   // Check if TClones is in folder
 458   // if not create and add to folder
 459   // connect to tree if available
 460   // Read the data
 461
 462   TObject** sdref = SDigitsRef();
 463   if(sdref == 0x0)
 464     {
 465       MakeSDigitsArray();
 466       sdref = SDigitsRef();
 467     }
 468
 469   TTree * treeS = TreeS();
 470   if(treeS==0)
 471     {
 472       //May happen if file is truncated or new in LoadSDigits
 473       //Error("ReadSDigits","There is no SDigit Tree");
 474       return 0;
 475     }
 476
 477   TBranch * branch = treeS->GetBranch(fDetectorName);
 478   if (branch == 0)
 479     {//easy, maybe just a new tree
 480       //Error("ReadSDigits"," Cannot find branch EMCAL");
 481       return 0;
 482     }
 483
 484   branch->SetAddress(SDigitsRef());
 485   branch->GetEntry(0);
 486   return 0;
 487 }
 488
 489 //____________________________________________________________________________
 490 Int_t AliEMCALLoader::ReadDigits()
 491 {
 492   // Read the summable digits tree TreeS():
 493   // Check if TClones is in folder
 494   // if not create and add to folder
 495   // connect to tree if available
 496   // Read the data
 497
 498   TObject** dref = DigitsRef();
 499   if(dref == 0x0)
 500     {//if there is not array in folder, create it and put it there
 501       MakeDigitsArray();
 502       dref = DigitsRef();
 503     }
 504
 505   TTree * treeD = TreeD();
 506   if(treeD==0)
 507     {
 508       //May happen if file is truncated or new in LoadSDigits
 509       //Error("ReadDigits","There is no Digit Tree");
 510       return 0;
 511     }
 512
 513   TBranch * branch = treeD->GetBranch(fDetectorName);
 514   if (branch == 0)
 515     {//easy, maybe just a new tree
 516       //Error("ReadDigits"," Cannot find branch ",fDetectorName.Data());
 517       return 0;
 518     }
 519
 520   branch->SetAddress(dref);//connect branch to buffer sitting in folder
 521   branch->GetEntry(0);//get first event
 522
 523   return 0;
 524 }
 525
 526 //____________________________________________________________________________
 527 void AliEMCALLoader::UnloadRecParticles()
 528 {
 529   // Unloads the RecParticles array fromthe folder structure
 530   fRecParticlesLoaded = kFALSE;
 531   CleanRecParticles();
 532   if (fTracksLoaded == kFALSE) UnloadTracks();
 533 }
 534
 535 //____________________________________________________________________________
 536 void AliEMCALLoader::UnloadTracks()
 537 {
 538   // Unloads the Tracks array fromthe folder structure
 539   CleanTracks();//free the memory
 540   //in case RecPart are loaded we can not onload tree and close the file
 541   if (fRecParticlesLoaded == kFALSE) AliLoader::UnloadTracks();
 542   fTracksLoaded = kFALSE;//mark that nobody needs them
 543 }
 544
 545 //____________________________________________________________________________
 546 void AliEMCALLoader::Track(Int_t itrack)
 547 {
 548   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
 549   if(TreeH()== 0)
 550     {
 551       if (LoadHits())
 552         {
 553           Error("Track","Can not load hits.");
 554           return;
 555         }
 556     }
 557
 558   TBranch * hitsbranch = dynamic_cast<TBranch*>(TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
 559   if ( !hitsbranch ) {
 560     if (fDebug)
 561       cout << "WARNING:  AliEMCALLoader::ReadTreeH -> Cannot find branch EMCAL" << endl ;
 562     return ;
 563   }
 564   if(!Hits()) PostHits();
 565
 566   hitsbranch->SetAddress(HitsRef());
 567   hitsbranch->GetEntry(itrack);
 568
 569 }
 570
 571 //____________________________________________________________________________
 572 Int_t AliEMCALLoader::ReadRecPoints()
 573 {
 574   //Creates and posts to folder an array container,
 575   //connects branch in tree (if exists), and reads data to array
 576
 577   MakeRecPointsArray();
 578
 579   TObjArray * eca = 0x0 ;
 580
 581   TTree * treeR = TreeR();
 582
 583   if(treeR==0)
 584     {
 585       //May happen if file is truncated or new in LoadSDigits
 586       return 0;
 587     }
 588
 589   Int_t retval = 0;
 590
 591   TBranch * ecabranch = treeR->GetBranch(fgkECARecPointsBranchName);
 592   if (ecabranch == 0x0)
 593     {
 594       Error("ReadRecPoints","Can not get branch with ECA Rec. Points named %s",fgkECARecPointsBranchName.Data());
 595       retval = 2;
 596     }
 597   else
 598    {
 599      ecabranch->SetAddress(&eca);
 600      ecabranch->GetEntry(0) ;
 601    }
 602
 603
 604   Int_t ii ;
 605
 606   Int_t maxeca = eca->GetEntries() ;
 607   for ( ii= 0 ; ii < maxeca ; ii++ )
 608     ECARecPoints()->Add(eca->At(ii)) ;
 609
 610   return retval;
 611 }
 612
 613 //____________________________________________________________________________
 614 Int_t AliEMCALLoader::ReadTracks()
 615 {
 616   //Creates and posts to folder an array container,
 617   //connects branch in tree (if exists), and reads data to arry
 618
 619   TObject** trkref = TracksRef();
 620   if ( trkref == 0x0 )
 621     {//Create and post array
 622       MakeTrackSegmentsArray();
 623       trkref = TracksRef();
 624     }
 625
 626   TTree * treeT = TreeT();
 627   if(treeT==0)
 628     {
 629       //May happen if file is truncated or new in LoadSDigits, or the file is in update mode,
 630       //but tracking was not performed yet for a current event
 631       //Error("ReadTracks","There is no Tree with Tracks");
 632       return 0;
 633     }
 634
 635   TBranch * branch = treeT->GetBranch(fgkTrackSegmentsBranchName);
 636   if (branch == 0)
 637     {//easy, maybe just a new tree
 638       Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
 639       return 0;
 640     }
 641
 642   branch->SetAddress(trkref);//connect branch to buffer sitting in folder
 643   branch->GetEntry(0);//get first event
 644
 645   return 0;
 646 }
 647
 648 //____________________________________________________________________________
 649 Int_t AliEMCALLoader::ReadRecParticles()
 650 {
 651   //Reads Reconstructed  Particles from file
 652   //Creates and posts to folder an array container,
 653   //connects branch in tree (if exists), and reads data to arry
 654
 655   TObject** recpartref = RecParticlesRef();
 656
 657   if ( recpartref == 0x0 )
 658     {//Create and post array
 659       MakeRecParticlesArray();
 660       recpartref = RecParticlesRef();
 661     }
 662
 663   TTree * treeP = TreeP();
 664   if(treeP==0)
 665     {
 666       //May happen if file is truncated or new in LoadSDigits,
 667       //or the file is in update mode,
 668       //but tracking was not performed yet for a current event
 669       //     Error("ReadRecParticles","There is no Tree with Tracks and Reconstructed Particles");
 670       return 0;
 671     }
 672
 673   TBranch * branch = treeP->GetBranch(fgkRecParticlesBranchName);
 674   if (branch == 0)
 675     {//easy, maybe just a new tree
 676       Error("ReadRecParticles"," Cannot find branch %s",fgkRecParticlesBranchName.Data());
 677       return 0;
 678     }
 679
 680   branch->SetAddress(recpartref);//connect branch to buffer sitting in folder
 681   branch->GetEntry(0);//get first event
 682
 683   return 0;
 684 }
 685
 686 //____________________________________________________________________________
 687 AliEMCALGeometry* AliEMCALLoader::GetEMCALGeometry()
 688 {
 689   //returns EMCAL geometry from gAlice
 690   //static Method used by some classes where it is not convienient to pass eventfoldername
 691   if (gAlice == 0x0)
 692     return 0x0;
 693   AliEMCAL* emcal=dynamic_cast<AliEMCAL*>(gAlice->GetDetector("EMCAL"));
 694   if (emcal == 0x0)
 695     return 0x0;
 696   return emcal->GetGeometry();
 697 }
 698
 699 //____________________________________________________________________________
 700 AliEMCALLoader* AliEMCALLoader::GetEMCALLoader(const  char* eventfoldername)
 701 {
 702   // Get an instance of the EMCALLoader object
 703   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
 704   if (rn == 0x0)
 705     {
 706       cerr<<"Error: <AliEMCALLoader::GetEMCALLoader>: "
 707           << "Can not find Run Loader in folder "<<eventfoldername<<endl;
 708       return 0x0;
 709     }
 710   return dynamic_cast<AliEMCALLoader*>(rn->GetLoader("EMCALLoader"));
 711 }
 712
 713 //____________________________________________________________________________
 714 Bool_t AliEMCALLoader::BranchExists(const TString& recName)
 715 {
 716   if (fBranchTitle.IsNull()) return kFALSE;
 717   TString dataname, zername ;
 718   TTree* tree;
 719   if(recName == "SDigits") {
 720     tree = TreeS();
 721     dataname = GetDetectorName();
 722     zername = "AliEMCALSDigitizer" ;
 723   }
 724   else if(recName == "Digits"){
 725     tree = TreeD();
 726     dataname = GetDetectorName();
 727     zername = "AliEMCALDigitizer" ;
 728   }
 729   else if(recName == "ECARecPoints"){
 730     tree = TreeR();
 731     dataname = fgkECARecPointsBranchName;
 732     zername = "AliEMCALClusterizer" ;
 733   }
 734   else if(recName == "TrackSegments"){
 735     tree = TreeT();
 736     dataname = fgkTrackSegmentsBranchName;
 737     zername = "AliEMCALTrackSegmentMaker";
 738   }
 739   else if(recName == "RecParticles"){
 740     tree = TreeP();
 741     dataname = fgkRecParticlesBranchName;
 742     zername = "AliEMCALPID";
 743   }
 744   else
 745     return kFALSE ;
 746
 747   if(!tree )
 748     return kFALSE ;
 749
 750   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
 751   TIter next(lob) ;
 752   TBranch * branch = 0 ;
 753   TString titleName(fBranchTitle);
 754   titleName+=":";
 755
 756   while ((branch = (static_cast<TBranch*>(next())))) {
 757     TString branchName(branch->GetName() ) ;
 758     TString branchTitle(branch->GetTitle() ) ;
 759     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){
 760       Warning("BranchExists","branch %s  with title  %s ",dataname.Data(),fBranchTitle.Data());
 761       return kTRUE ;
 762     }
 763     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
 764       Warning("BranchExists","branch AliEMCAL... with title  %s ",branch->GetTitle());
 765       return kTRUE ;
 766     }
 767   }
 768   return kFALSE ;
 769
 770 }
 771
 772 //____________________________________________________________________________
 773 void AliEMCALLoader::SetBranchTitle(const TString& btitle)
 774 {
 775   // Gives a name to a branch in the folder structure
 776   if (btitle.CompareTo(fBranchTitle) == 0) return;
 777   fBranchTitle = btitle;
 778   ReloadAll();
 779 }
 780
 781 //____________________________________________________________________________
 782 void AliEMCALLoader::CleanHits()
 783 {
 784   AliLoader::CleanHits();
 785   //Clear an array
 786   TClonesArray* hits = Hits();
 787   if (hits) hits->Clear();
 788 }
 789
 790 //____________________________________________________________________________
 791 void AliEMCALLoader::CleanSDigits()
 792 {
 793   // Cleans the SDigits array in the folder structure
 794   AliLoader::CleanSDigits();
 795   TClonesArray* sdigits = SDigits();
 796   if (sdigits) sdigits->Clear();
 797
 798 }
 799 //____________________________________________________________________________
 800
 801 void AliEMCALLoader::CleanDigits()
 802 {
 803   // Cleans the Digits array in the folder structure
 804   AliLoader::CleanDigits();
 805   TClonesArray* digits = Digits();
 806   if (digits) digits->Clear();
 807 }
 808
 809 //____________________________________________________________________________
 810 void AliEMCALLoader::CleanRecPoints()
 811 {
 812   // Cleans the RecPoints array in the folder structure
 813   AliLoader::CleanRecPoints();
 814   TObjArray* recpoints = ECARecPoints();
 815   if (recpoints) recpoints->Clear();
 816
 817 }
 818
 819 //____________________________________________________________________________
 820 void AliEMCALLoader::CleanTracks()
 821 {
 822   // Cleans the Tracks array in the folder structure
 823   AliLoader::CleanTracks();//tree
 824   //and clear the array
 825   TClonesArray* tracks = TrackSegments();
 826   if (tracks)
 827     tracks->Clear();
 828 }
 829
 830 //____________________________________________________________________________
 831 void AliEMCALLoader::CleanRecParticles()
 832 {
 833   // Cleans the RecParticles array in the folder structure
 834   TClonesArray *recpar = RecParticles();
 835   if (recpar)
 836     recpar->Clear();
 837 }
 838
 839 //____________________________________________________________________________
 840 // void AliEMCALLoader::ReadCalibrationDB(const char * database,const char * filename)
 841 // {
 842
 843 //   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
 844 //     return ;
 845
 846 //   TFile * file = gROOT->GetFile(filename) ;
 847 //   if(!file)
 848 //     file = TFile::Open(filename);
 849 //   if(!file){
 850 //     Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
 851 //     return ;
 852 //   }
 853 //   if(fcdb)
 854 //     fcdb->Delete() ;
 855 //   fcdb = dynamic_cast<AliEMCALCalibrationDB *>(file->Get("AliEMCALCalibrationDB")) ;
 856 //   if(!fcdb)
 857 //     Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
 858 // }
 859 //____________________________________________________________________________
 860
 861 // AliEMCALSDigitizer*  AliEMCALLoader::EMCALSDigitizer()
 862 // {
 863 // //return EMCAL SDigitizer
 864 //  return  dynamic_cast<AliEMCALSDigitizer*>(SDigitizer()) ;
 865 // }
 866
 867 //____________________________________________________________________________
 868 void AliEMCALLoader::MakeHitsArray()
 869 {
 870   // Create the array for Hits
 871   if (Hits()) return;
 872   TClonesArray* hits = new TClonesArray("AliEMCALHit",1000);
 873   hits->SetName(fgkHitsName);
 874   GetDetectorDataFolder()->Add(hits);
 875 }
 876
 877 //____________________________________________________________________________
 878 void AliEMCALLoader::MakeSDigitsArray()
 879 {
 880   // Create the array for SDigits
 881   if ( SDigits()) return;
 882   TClonesArray* sdigits = new TClonesArray("AliEMCALDigit",1);
 883   sdigits->SetName(fgkSDigitsName);
 884   GetDetectorDataFolder()->Add(sdigits);
 885 }
 886
 887 //____________________________________________________________________________
 888 void AliEMCALLoader::MakeDigitsArray()
 889 {
 890   // Create the array for Digits
 891   if ( Digits()) return;
 892   TClonesArray* digits = new TClonesArray("AliEMCALDigit",1);
 893   digits->SetName(fgkDigitsName);
 894   GetDetectorDataFolder()->Add(digits);
 895
 896 }
 897
 898 //____________________________________________________________________________
 899 void AliEMCALLoader::MakeRecPointsArray()
 900 {
 901   if ( ECARecPoints() == 0x0) {
 902     if (GetDebug()>9)
 903       printf("MakeRecPointsArray: Making array for ECA");
 904     TObjArray* eca = new TObjArray(100) ;
 905     eca->SetName(fgkECARecPointsName) ;
 906     GetDetectorDataFolder()->Add(eca);
 907    }
 908 }
 909
 910 //____________________________________________________________________________
 911 void AliEMCALLoader::MakeTrackSegmentsArray()
 912 {
 913   // Create the array for TrackSegments
 914   if ( TrackSegments())
 915     return;
 916   TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
 917   ts->SetName(fgkTracksName);
 918   GetDetectorDataFolder()->Add(ts);
 919 }
 920
 921 //____________________________________________________________________________
 922 void AliEMCALLoader::MakeRecParticlesArray()
 923 {
 924   // Create the array for RecParticles
 925   if ( RecParticles()) return;
 926   TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
 927   rp->SetName(fgkRecParticlesName);
 928   GetDetectorDataFolder()->Add(rp);
 929 }