EMCAL/AliEMCALGetter.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  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 //  AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ;
  29 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
  30 //     AliEMCALRecParticle * part = gime->RecParticle(1) ;
  31 //     ................
  32 //  gime->Event(event) ;    // reads new event from galice.root
  33 //
  34 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  35 //*--         Completely redesigned by Dmitri Peressounko March 2001
  36 //
  37 //*-- YS June 2001 : renamed the original AliEMCALIndexToObject and make
  38 //*--         systematic usage of TFolders without changing the interface
  39 //////////////////////////////////////////////////////////////////////////////
  40
  41 // --- ROOT system ---
  42
  43 #include "TSystem.h"
  44 #include "TFile.h"
  45 // #include "TTree.h"
  46 #include "TROOT.h"
  47 // #include "TObjString.h"
  48 // #include "TFolder.h"
  49 // #include "TParticle.h"
  50
  51 // --- Standard library ---
  52
  53 // --- AliRoot header files ---
  54 // #include "AliRun.h"
  55 // #include "AliConfig.h"
  56 #include "AliEMCALGetter.h"
  57 #include "AliEMCAL.h"
  58 #include "AliRunLoader.h"
  59 #include "AliStack.h"
  60 #include "AliEMCALLoader.h"
  61 #include "AliMC.h"
  62
  63 ClassImp(AliEMCALGetter)
  64
  65 AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ;
  66 AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
  67 Int_t AliEMCALGetter::fgDebug = 0;
  68
  69 //  TFile * AliEMCALGetter::fgFile = 0 ;
  70
  71 //____________________________________________________________________________
  72 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption)
  73 {
  74   // ctor only called by Instance()
  75
  76   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ;
  77   if (!rl) {
  78     rl = AliRunLoader::Open(headerFile, version, openingOption);
  79     if (!rl) {
  80       Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ;
  81       return ;
  82     }
  83     if (rl->GetAliRun() == 0x0) {
  84       rl->LoadgAlice();
  85       gAlice = rl->GetAliRun(); // should be removed
  86     }
  87   }
  88   fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
  89   if ( !fgEmcalLoader )
  90     Error("AliEMCALGetter", "Could not find EMCALLoader") ;
  91   else
  92     fgEmcalLoader->SetTitle(version);
  93
  94
  95   // initialize data members
  96   SetDebug(0) ;
  97   //fBTE = 0 ;
  98   fPrimaries = 0 ;
  99   fLoadingStatus = "" ;
 100 }
 101
 102 //____________________________________________________________________________
 103 AliEMCALGetter::~AliEMCALGetter()
 104 {
 105   // dtor
 106   delete fgEmcalLoader ;
 107   fgEmcalLoader = 0 ;
 108   //delete fBTE ;
 109   // fBTE = 0 ;
 110   fPrimaries->Delete() ;
 111   delete fPrimaries ;
 112 }
 113
 114 //____________________________________________________________________________
 115 AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
 116 {
 117   AliEMCALClusterizer * rv ;
 118   rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
 119   if (!rv) {
 120     Event(0, "R") ;
 121     rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
 122   }
 123   return rv ;
 124 }
 125
 126
 127 //____________________________________________________________________________
 128 TClonesArray * AliEMCALGetter::Digits()
 129 {
 130   // asks the Loader to return the Digits container
 131
 132   TClonesArray * rv = 0 ;
 133   rv = EmcalLoader()->Digits() ;
 134
 135   if( !rv ) {
 136     EmcalLoader()->MakeDigitsArray() ;
 137     rv = EmcalLoader()->Digits() ;
 138   }
 139   return rv ;
 140 }
 141
 142 //____________________________________________________________________________
 143 AliEMCALDigitizer * AliEMCALGetter::Digitizer()
 144 {
 145   AliEMCALDigitizer * rv ;
 146   rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
 147   if (!rv) {
 148     Event(0, "D") ;
 149     rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
 150   }
 151   return rv ;
 152 }
 153
 154
 155 //____________________________________________________________________________
 156 TObjArray * AliEMCALGetter::PRERecPoints()
 157 {
 158   // asks the Loader to return the EMC RecPoints container
 159
 160   TObjArray * rv = 0 ;
 161
 162   rv = EmcalLoader()->PRERecPoints() ;
 163   if (!rv) {
 164     EmcalLoader()->MakeRecPointsArray() ;
 165     rv = EmcalLoader()->PRERecPoints() ;
 166   }
 167   return rv ;
 168 }
 169
 170 //____________________________________________________________________________
 171 TObjArray * AliEMCALGetter::ECARecPoints()
 172 {
 173   // asks the Loader to return the EMC RecPoints container
 174
 175   TObjArray * rv = 0 ;
 176
 177   rv = EmcalLoader()->ECARecPoints() ;
 178   if (!rv) {
 179     EmcalLoader()->MakeRecPointsArray() ;
 180     rv = EmcalLoader()->ECARecPoints() ;
 181   }
 182   return rv ;
 183 }
 184
 185 //____________________________________________________________________________
 186 TObjArray * AliEMCALGetter::HCARecPoints()
 187 {
 188   // asks the Loader to return the EMC RecPoints container
 189
 190   TObjArray * rv = 0 ;
 191
 192   rv = EmcalLoader()->HCARecPoints() ;
 193   if (!rv) {
 194     EmcalLoader()->MakeRecPointsArray() ;
 195     rv = EmcalLoader()->HCARecPoints() ;
 196   }
 197   return rv ;
 198 }
 199
 200 //____________________________________________________________________________
 201 TClonesArray * AliEMCALGetter::TrackSegments()
 202 {
 203   // asks the Loader to return the TrackSegments container
 204
 205   TClonesArray * rv = 0 ;
 206
 207   rv = EmcalLoader()->TrackSegments() ;
 208   if (!rv) {
 209     EmcalLoader()->MakeTrackSegmentsArray() ;
 210     rv = EmcalLoader()->TrackSegments() ;
 211   }
 212   return rv ;
 213 }
 214
 215 //____________________________________________________________________________
 216 AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker()
 217 {
 218   AliEMCALTrackSegmentMaker * rv ;
 219   rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
 220   if (!rv) {
 221     Event(0, "T") ;
 222     rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
 223   }
 224   return rv ;
 225 }
 226
 227 //____________________________________________________________________________
 228 TClonesArray * AliEMCALGetter::RecParticles()
 229 {
 230   // asks the Loader to return the TrackSegments container
 231
 232   TClonesArray * rv = 0 ;
 233
 234   rv = EmcalLoader()->RecParticles() ;
 235   if (!rv) {
 236     EmcalLoader()->MakeRecParticlesArray() ;
 237     rv = EmcalLoader()->RecParticles() ;
 238   }
 239   return rv ;
 240 }
 241 //____________________________________________________________________________
 242 void AliEMCALGetter::Event(const Int_t event, const char* opt)
 243 {
 244   // Reads the content of all Tree's S, D and R
 245
 246   if ( event >= MaxEvent() ) {
 247     Error("Event", "%d not found in TreeE !", event) ;
 248     return ;
 249   }
 250
 251   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 252
 253   // checks if we are dealing with test-beam data
 254 //   TBranch * btb = rl->TreeE()->GetBranch("AliEMCALBeamTestEvent") ;
 255 //   if(btb){
 256 //     if(!fBTE)
 257 //       fBTE = new AliEMCALBeamTestEvent() ;
 258 //     btb->SetAddress(&fBTE) ;
 259 //     btb->GetEntry(event) ;
 260 //   }
 261 //   else{
 262 //     if(fBTE){
 263 //       delete fBTE ;
 264 //       fBTE = 0 ;
 265 //     }
 266 //   }
 267
 268   // Loads the type of object(s) requested
 269
 270   rl->GetEvent(event) ;
 271
 272   if( strstr(opt,"X") || (strcmp(opt,"")==0) )
 273     ReadPrimaries() ;
 274
 275   if(strstr(opt,"H") )
 276     ReadTreeH();
 277
 278   if(strstr(opt,"S") )
 279     ReadTreeS() ;
 280
 281   if( strstr(opt,"D") )
 282     ReadTreeD() ;
 283
 284   if( strstr(opt,"R") )
 285     ReadTreeR() ;
 286
 287   if( strstr(opt,"T") )
 288     ReadTreeT() ;
 289
 290   if( strstr(opt,"P") )
 291     ReadTreeP() ;
 292
 293 //   if( strstr(opt,"Q") )
 294 //     ReadTreeQA() ;
 295
 296 }
 297
 298
 299 //____________________________________________________________________________
 300 Int_t AliEMCALGetter::EventNumber() const
 301   {
 302   // return the current event number
 303   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 304   return static_cast<Int_t>(rl->GetEventNumber()) ;
 305 }
 306
 307 //____________________________________________________________________________
 308   TClonesArray * AliEMCALGetter::Hits()
 309 {
 310   // asks the loader to return  the Hits container
 311
 312   TClonesArray * rv = 0 ;
 313
 314   rv = EmcalLoader()->Hits() ;
 315   if ( !rv ) {
 316     EmcalLoader()->LoadHits("read");
 317     rv = EmcalLoader()->Hits() ;
 318   }
 319   return rv ;
 320 }
 321
 322 //____________________________________________________________________________
 323 AliEMCALGetter * AliEMCALGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
 324 {
 325   // Creates and returns the pointer of the unique instance
 326   // Must be called only when the environment has changed
 327
 328   //::Info("Instance","alirunFileName=%s version=%s openingOption=%s",alirunFileName,version,openingOption);
 329
 330   if(!fgObjGetter){ // first time the getter is called
 331     fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
 332   }
 333   else { // the getter has been called previously
 334     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
 335     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
 336       // check if the file is already open
 337       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ;
 338
 339       if ( !galiceFile )
 340         fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
 341
 342       else {  // the file is already open check the version name
 343         TString currentVersionName = rl->GetEventFolder()->GetName() ;
 344         TString newVersionName(version) ;
 345         if (currentVersionName == newVersionName)
 346           if(fgDebug)
 347             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;
 348         else {
 349           fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
 350         }
 351       }
 352     }
 353     else
 354       fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
 355   }
 356   if (!fgObjGetter)
 357     ::Error("Instance", "Failed to create the EMCAL Getter object") ;
 358   else
 359     if (fgDebug)
 360       Print() ;
 361
 362   return fgObjGetter ;
 363 }
 364
 365 //____________________________________________________________________________
 366 AliEMCALGetter *  AliEMCALGetter::Instance()
 367 {
 368   // Returns the pointer of the unique instance already defined
 369
 370   if(!fgObjGetter)
 371      ::Error("Instance", "Getter not initialized") ;
 372
 373    return fgObjGetter ;
 374
 375 }
 376
 377 //____________________________________________________________________________
 378 Int_t AliEMCALGetter::MaxEvent() const
 379 {
 380   // returns the number of events in the run (from TE)
 381
 382   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 383   return static_cast<Int_t>(rl->GetNumberOfEvents()) ;
 384 }
 385
 386 //____________________________________________________________________________
 387 TParticle * AliEMCALGetter::Primary(Int_t index) const
 388 {
 389   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 390   return rl->Stack()->Particle(index) ;
 391 }
 392
 393 //____________________________________________________________________________
 394 AliEMCAL * AliEMCALGetter:: EMCAL() const
 395 {
 396   // returns the EMCAL object
 397   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(EmcalLoader()->GetModulesFolder()->FindObject("EMCAL")) ;
 398   if (!emcal)
 399     if (fgDebug)
 400       Warning("EMCAL", "EMCAL module not found in module folders: %s", EmcalLoader()->GetModulesFolder()->GetName() ) ;
 401   return emcal ;
 402 }
 403
 404
 405
 406 //____________________________________________________________________________
 407 AliEMCALPID * AliEMCALGetter::PID()
 408 {
 409   AliEMCALPID * rv ;
 410   rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
 411   if (!rv) {
 412     Event(0, "P") ;
 413     rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
 414   }
 415   return rv ;
 416 }
 417
 418 //____________________________________________________________________________
 419 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() const
 420 {
 421   // Returns EMCAL geometry
 422
 423   AliEMCALGeometry * rv = 0 ;
 424   if (EMCAL() )
 425     rv =  EMCAL()->GetGeometry() ;
 426   return rv ;
 427 }
 428
 429 //____________________________________________________________________________
 430 TClonesArray * AliEMCALGetter::Primaries()
 431 {
 432   // creates the Primaries container if needed
 433   if ( !fPrimaries ) {
 434     if (fgDebug)
 435       Info("Primaries", "Creating a new TClonesArray for primaries") ;
 436     fPrimaries = new TClonesArray("TParticle", 1000) ;
 437   }
 438   return fPrimaries ;
 439 }
 440
 441 //____________________________________________________________________________
 442 void  AliEMCALGetter::Print()
 443 {
 444   // Print usefull information about the getter
 445
 446   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
 447   ::Info( "Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ;
 448 }
 449
 450 //____________________________________________________________________________
 451 void AliEMCALGetter::ReadPrimaries()
 452 {
 453   // Read Primaries from Kinematics.root
 454
 455   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 456
 457   // gets kine tree from the root file (Kinematics.root)
 458   if ( ! rl->TreeK() )  // load treeK the first time
 459     rl->LoadKinematics() ;
 460
 461   fNPrimaries = rl->Stack()->GetNtrack() ;
 462
 463   if (fgDebug)
 464     Info( "ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ;
 465
 466
 467   // first time creates the container
 468   if ( Primaries() )
 469     fPrimaries->Clear() ;
 470
 471   Int_t index = 0 ;
 472   for (index = 0 ; index < fNPrimaries; index++) {
 473     new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
 474   }
 475 }
 476
 477 //____________________________________________________________________________
 478 Int_t AliEMCALGetter::ReadTreeD()
 479 {
 480   // Read the Digits
 481
 482
 483   // gets TreeD from the root file (EMCAL.SDigits.root)
 484   if ( !IsLoaded("D") ) {
 485     EmcalLoader()->LoadDigits("UPDATE") ;
 486     EmcalLoader()->LoadDigitizer("UPDATE") ;
 487     SetLoaded("D") ;
 488   }
 489   return Digits()->GetEntries() ;
 490 }
 491
 492 //____________________________________________________________________________
 493 Int_t AliEMCALGetter::ReadTreeH()
 494 {
 495   // Read the Hits
 496
 497   // gets TreeH from the root file (EMCAL.Hit.root)
 498   if ( !IsLoaded("H") ) {
 499     EmcalLoader()->LoadHits("UPDATE") ;
 500     SetLoaded("H") ;
 501   }
 502   return Hits()->GetEntries() ;
 503 }
 504
 505 //____________________________________________________________________________
 506 Int_t AliEMCALGetter::ReadTreeR()
 507 {
 508   // Read the RecPoints
 509
 510
 511   // gets TreeR from the root file (EMCAL.RecPoints.root)
 512   if ( !IsLoaded("R") ) {
 513     EmcalLoader()->LoadRecPoints("UPDATE") ;
 514     EmcalLoader()->LoadClusterizer("UPDATE") ;
 515     SetLoaded("R") ;
 516   }
 517
 518   return ECARecPoints()->GetEntries() ;
 519 }
 520
 521 //____________________________________________________________________________
 522 Int_t AliEMCALGetter::ReadTreeT()
 523 {
 524   // Read the TrackSegments
 525
 526
 527   // gets TreeT from the root file (EMCAL.TrackSegments.root)
 528   if ( !IsLoaded("T") ) {
 529     EmcalLoader()->LoadTracks("UPDATE") ;
 530     EmcalLoader()->LoadTrackSegmentMaker("UPDATE") ;
 531     SetLoaded("T") ;
 532   }
 533
 534   return TrackSegments()->GetEntries() ;
 535 }
 536 //____________________________________________________________________________
 537 Int_t AliEMCALGetter::ReadTreeP()
 538 {
 539   // Read the TrackSegments
 540
 541
 542   // gets TreeT from the root file (EMCAL.TrackSegments.root)
 543   if ( !IsLoaded("P") ) {
 544     EmcalLoader()->LoadRecParticles("UPDATE") ;
 545     EmcalLoader()->LoadPID("UPDATE") ;
 546     SetLoaded("P") ;
 547   }
 548
 549   return RecParticles()->GetEntries() ;
 550 }
 551 //____________________________________________________________________________
 552 Int_t AliEMCALGetter::ReadTreeS()
 553 {
 554   // Read the SDigits
 555
 556
 557   // gets TreeS from the root file (EMCAL.SDigits.root)
 558   if ( !IsLoaded("S") ) {
 559     EmcalLoader()->LoadSDigits("UPDATE") ;
 560     EmcalLoader()->LoadSDigitizer("UPDATE") ;
 561     SetLoaded("S") ;
 562   }
 563
 564   return SDigits()->GetEntries() ;
 565 }
 566
 567 //____________________________________________________________________________
 568 TClonesArray * AliEMCALGetter::SDigits()
 569 {
 570   // asks the Loader to return the Digits container
 571
 572   TClonesArray * rv = 0 ;
 573
 574   rv = EmcalLoader()->SDigits() ;
 575   if (!rv) {
 576     EmcalLoader()->MakeSDigitsArray() ;
 577     rv = EmcalLoader()->SDigits() ;
 578   }
 579   return rv ;
 580 }
 581
 582 //____________________________________________________________________________
 583 AliEMCALSDigitizer * AliEMCALGetter::SDigitizer()
 584 {
 585   AliEMCALSDigitizer * rv ;
 586   rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
 587   if (!rv) {
 588     Event(0, "S") ;
 589     rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
 590   }
 591   return rv ;
 592 }
 593
 594 //____________________________________________________________________________
 595 TParticle * AliEMCALGetter::Secondary(const TParticle* p, const Int_t index) const
 596 {
 597   // Return first (index=1) or second (index=2) secondary particle of primary particle p
 598
 599   if(index <= 0)
 600     return 0 ;
 601   if(index > 2)
 602     return 0 ;
 603
 604   if(p) {
 605   Int_t daughterIndex = p->GetDaughter(index-1) ;
 606   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 607   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
 608   }
 609   else
 610     return 0 ;
 611 }
 612
 613 //____________________________________________________________________________
 614 void AliEMCALGetter::Track(const Int_t itrack)
 615 {
 616   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
 617
 618  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 619
 620   if( !TreeH() ) // load treeH the first time
 621     rl->LoadHits() ;
 622
 623   // first time create the container
 624   TClonesArray * hits = Hits() ;
 625   if ( hits )
 626     hits->Clear() ;
 627
 628   TBranch * emcalbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("EMCAL")) ;
 629   emcalbranch->SetAddress(&hits) ;
 630   emcalbranch->GetEntry(itrack) ;
 631 }
 632
 633 //____________________________________________________________________________
 634 TTree * AliEMCALGetter::TreeD() const
 635 {
 636   TTree * rv = 0 ;
 637   rv = EmcalLoader()->TreeD() ;
 638   if ( !rv ) {
 639     EmcalLoader()->MakeTree("D");
 640     rv = EmcalLoader()->TreeD() ;
 641   }
 642
 643   return rv ;
 644 }
 645
 646 //____________________________________________________________________________
 647 TTree * AliEMCALGetter::TreeH() const
 648 {
 649   TTree * rv = 0 ;
 650   rv = EmcalLoader()->TreeH() ;
 651   if ( !rv ) {
 652     EmcalLoader()->MakeTree("H");
 653     rv = EmcalLoader()->TreeH() ;
 654   }
 655
 656   return rv ;
 657 }
 658
 659 //____________________________________________________________________________
 660 TTree * AliEMCALGetter::TreeR() const
 661 {
 662   TTree * rv = 0 ;
 663   rv = EmcalLoader()->TreeR() ;
 664   if ( !rv ) {
 665     EmcalLoader()->MakeTree("R");
 666     rv = EmcalLoader()->TreeR() ;
 667   }
 668
 669   return rv ;
 670 }
 671
 672 //____________________________________________________________________________
 673 TTree * AliEMCALGetter::TreeT() const
 674 {
 675   TTree * rv = 0 ;
 676   rv = EmcalLoader()->TreeT() ;
 677   if ( !rv ) {
 678     EmcalLoader()->MakeTree("T");
 679     rv = EmcalLoader()->TreeT() ;
 680   }
 681
 682   return rv ;
 683 }
 684 //____________________________________________________________________________
 685 TTree * AliEMCALGetter::TreeP() const
 686 {
 687   TTree * rv = 0 ;
 688   rv = EmcalLoader()->TreeP() ;
 689   if ( !rv ) {
 690     EmcalLoader()->MakeTree("P");
 691     rv = EmcalLoader()->TreeP() ;
 692   }
 693
 694   return rv ;
 695 }
 696
 697 //____________________________________________________________________________
 698 TTree * AliEMCALGetter::TreeS() const
 699 {
 700   TTree * rv = 0 ;
 701   rv = EmcalLoader()->TreeS() ;
 702   if ( !rv ) {
 703     EmcalLoader()->MakeTree("S");
 704     rv = EmcalLoader()->TreeS() ;
 705   }
 706
 707   return rv ;
 708 }
 709
 710 //____________________________________________________________________________
 711 Bool_t AliEMCALGetter::VersionExists(TString & opt) const
 712 {
 713   // checks if the version with the present name already exists in the same directory
 714
 715   Bool_t rv = kFALSE ;
 716
 717   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 718   TString version( rl->GetEventFolder()->GetName() ) ;
 719
 720   opt.ToLower() ;
 721
 722   if ( opt == "sdigits") {
 723     // add the version name to the root file name
 724     TString fileName( EmcalLoader()->GetSDigitsFileName() ) ;
 725     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
 726       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 727     if ( !(gSystem->AccessPathName(fileName)) ) {
 728       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 729       rv = kTRUE ;
 730     }
 731     EmcalLoader()->SetSDigitsFileName(fileName) ;
 732   }
 733
 734   if ( opt == "digits") {
 735     // add the version name to the root file name
 736     TString fileName( EmcalLoader()->GetDigitsFileName() ) ;
 737     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
 738       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 739     if ( !(gSystem->AccessPathName(fileName)) ) {
 740       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 741       rv = kTRUE ;
 742     }
 743     EmcalLoader()->SetDigitsFileName(fileName) ;
 744   }
 745
 746   return rv ;
 747
 748 }
 749
 750 //____________________________________________________________________________
 751 UShort_t AliEMCALGetter::EventPattern(void) const
 752 {
 753   // Return the pattern (trigger bit register) of the beam-test event
 754 //   if(fBTE)
 755 //     return fBTE->GetPattern() ;
 756 //   else
 757     return 0 ;
 758 }
 759 //____________________________________________________________________________
 760 Float_t AliEMCALGetter::BeamEnergy(void) const
 761 {
 762   // Return the beam energy of the beam-test event
 763 //   if(fBTE)
 764 //     return fBTE->GetBeamEnergy() ;
 765 //   else
 766     return 0 ;
 767 }