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