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