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 "TROOT.h"
  46
  47
  48 // --- Standard library ---
  49
  50 // --- AliRoot header files ---
  51
  52 #include "AliEMCALGetter.h"
  53 #include "AliEMCAL.h"
  54 #include "AliRunLoader.h"
  55 #include "AliStack.h"
  56 #include "AliEMCALLoader.h"
  57 #include "AliMC.h"
  58
  59 ClassImp(AliEMCALGetter)
  60
  61 AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ;
  62 AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
  63 Int_t AliEMCALGetter::fgDebug = 0;
  64
  65 //  TFile * AliEMCALGetter::fgFile = 0 ;
  66
  67 //____________________________________________________________________________
  68 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption)
  69 {
  70   // ctor only called by Instance()
  71
  72   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ;
  73   if (!rl) {
  74     rl = AliRunLoader::Open(headerFile, version, openingOption);
  75     if (!rl) {
  76       Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ;
  77       return ;
  78     }
  79     if (rl->GetAliRun() == 0x0) {
  80       rl->LoadgAlice();
  81       gAlice = rl->GetAliRun(); // should be removed
  82     }
  83   }
  84   fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
  85   if ( !fgEmcalLoader )
  86     Error("AliEMCALGetter", "Could not find EMCALLoader") ;
  87   else
  88     fgEmcalLoader->SetTitle(version);
  89
  90
  91   // initialize data members
  92   SetDebug(0) ;
  93   //fBTE = 0 ;
  94   fPrimaries = 0 ;
  95   fLoadingStatus = "" ;
  96 }
  97
  98 //____________________________________________________________________________
  99 AliEMCALGetter::~AliEMCALGetter()
 100 {
 101   // dtor
 102   delete fgEmcalLoader ;
 103   fgEmcalLoader = 0 ;
 104   //delete fBTE ;
 105   // fBTE = 0 ;
 106   fPrimaries->Delete() ;
 107   delete fPrimaries ;
 108 }
 109
 110 //____________________________________________________________________________
 111 AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
 112 {
 113   // return pointer to Clusterizer Tree
 114   AliEMCALClusterizer * rv ;
 115   rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
 116   if (!rv) {
 117     Event(0, "R") ;
 118     rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
 119   }
 120   return rv ;
 121 }
 122
 123
 124 //____________________________________________________________________________
 125 TClonesArray * AliEMCALGetter::Digits() const
 126 {
 127   // asks the Loader to return the Digits container
 128
 129   TClonesArray * rv = 0 ;
 130   rv = EmcalLoader()->Digits() ;
 131
 132   if( !rv ) {
 133     EmcalLoader()->MakeDigitsArray() ;
 134     rv = EmcalLoader()->Digits() ;
 135   }
 136   return rv ;
 137 }
 138
 139 //____________________________________________________________________________
 140 AliEMCALDigitizer * AliEMCALGetter::Digitizer()
 141 {
 142   // return pointer to Digitizer Tree
 143   AliEMCALDigitizer * rv ;
 144   rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
 145   if (!rv) {
 146     Event(0, "D") ;
 147     rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
 148   }
 149   return rv ;
 150 }
 151
 152
 153 //____________________________________________________________________________
 154 TObjArray * AliEMCALGetter::PRERecPoints() const
 155 {
 156   // asks the Loader to return the EMC RecPoints container
 157
 158   TObjArray * rv = 0 ;
 159
 160   rv = EmcalLoader()->PRERecPoints() ;
 161   if (!rv) {
 162     EmcalLoader()->MakeRecPointsArray() ;
 163     rv = EmcalLoader()->PRERecPoints() ;
 164   }
 165   return rv ;
 166 }
 167
 168 //____________________________________________________________________________
 169 TObjArray * AliEMCALGetter::ECARecPoints() const
 170 {
 171   // asks the Loader to return the EMC RecPoints container
 172
 173   TObjArray * rv = 0 ;
 174
 175   rv = EmcalLoader()->ECARecPoints() ;
 176   if (!rv) {
 177     EmcalLoader()->MakeRecPointsArray() ;
 178     rv = EmcalLoader()->ECARecPoints() ;
 179   }
 180   return rv ;
 181 }
 182
 183 //____________________________________________________________________________
 184 TObjArray * AliEMCALGetter::HCARecPoints() const
 185 {
 186   // asks the Loader to return the EMC RecPoints container
 187
 188   TObjArray * rv = 0 ;
 189
 190   rv = EmcalLoader()->HCARecPoints() ;
 191   if (!rv) {
 192     EmcalLoader()->MakeRecPointsArray() ;
 193     rv = EmcalLoader()->HCARecPoints() ;
 194   }
 195   return rv ;
 196 }
 197
 198 //____________________________________________________________________________
 199 TClonesArray * AliEMCALGetter::TrackSegments() const
 200 {
 201   // asks the Loader to return the TrackSegments container
 202
 203   TClonesArray * rv = 0 ;
 204
 205   rv = EmcalLoader()->TrackSegments() ;
 206   if (!rv) {
 207     EmcalLoader()->MakeTrackSegmentsArray() ;
 208     rv = EmcalLoader()->TrackSegments() ;
 209   }
 210   return rv ;
 211 }
 212
 213 //____________________________________________________________________________
 214 AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker()
 215 {
 216   // return pointer to TrackSegmentMaker Tree
 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() const
 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() const
 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   // return pointer to PID Tree
 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() const
 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   // return pointer to SDigitizer Tree
 586   AliEMCALSDigitizer * rv ;
 587   rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
 588   if (!rv) {
 589     Event(0, "S") ;
 590     rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
 591   }
 592   return rv ;
 593 }
 594
 595 //____________________________________________________________________________
 596 TParticle * AliEMCALGetter::Secondary(const TParticle* p, const Int_t index) const
 597 {
 598   // Return first (index=1) or second (index=2) secondary particle of primary particle p
 599
 600   if(index <= 0)
 601     return 0 ;
 602   if(index > 2)
 603     return 0 ;
 604
 605   if(p) {
 606   Int_t daughterIndex = p->GetDaughter(index-1) ;
 607   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 608   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
 609   }
 610   else
 611     return 0 ;
 612 }
 613
 614 //____________________________________________________________________________
 615 void AliEMCALGetter::Track(const Int_t itrack)
 616 {
 617   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
 618
 619  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 620
 621   if( !TreeH() ) // load treeH the first time
 622     rl->LoadHits() ;
 623
 624   // first time create the container
 625   TClonesArray * hits = Hits() ;
 626   if ( hits )
 627     hits->Clear() ;
 628
 629   TBranch * emcalbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("EMCAL")) ;
 630   emcalbranch->SetAddress(&hits) ;
 631   emcalbranch->GetEntry(itrack) ;
 632 }
 633
 634 //____________________________________________________________________________
 635 TTree * AliEMCALGetter::TreeD() const
 636 {
 637   // return pointer to Digits Tree
 638   TTree * rv = 0 ;
 639   rv = EmcalLoader()->TreeD() ;
 640   if ( !rv ) {
 641     EmcalLoader()->MakeTree("D");
 642     rv = EmcalLoader()->TreeD() ;
 643   }
 644
 645   return rv ;
 646 }
 647
 648 //____________________________________________________________________________
 649 TTree * AliEMCALGetter::TreeH() const
 650 {
 651   // return pointer to Hits Tree
 652   TTree * rv = 0 ;
 653   rv = EmcalLoader()->TreeH() ;
 654   if ( !rv ) {
 655     EmcalLoader()->MakeTree("H");
 656     rv = EmcalLoader()->TreeH() ;
 657   }
 658
 659   return rv ;
 660 }
 661
 662 //____________________________________________________________________________
 663 TTree * AliEMCALGetter::TreeR() const
 664 {
 665   // return pointer to RecPoints Tree
 666
 667   TTree * rv = 0 ;
 668   rv = EmcalLoader()->TreeR() ;
 669   if ( !rv ) {
 670     EmcalLoader()->MakeTree("R");
 671     rv = EmcalLoader()->TreeR() ;
 672   }
 673
 674   return rv ;
 675 }
 676
 677 //____________________________________________________________________________
 678 TTree * AliEMCALGetter::TreeT() const
 679 {
 680   // return pointer to TrackSegments Tree
 681   TTree * rv = 0 ;
 682   rv = EmcalLoader()->TreeT() ;
 683   if ( !rv ) {
 684     EmcalLoader()->MakeTree("T");
 685     rv = EmcalLoader()->TreeT() ;
 686   }
 687
 688   return rv ;
 689 }
 690 //____________________________________________________________________________
 691 TTree * AliEMCALGetter::TreeP() const
 692 {
 693   // return pointer to RecParticles Tree
 694   TTree * rv = 0 ;
 695   rv = EmcalLoader()->TreeP() ;
 696   if ( !rv ) {
 697     EmcalLoader()->MakeTree("P");
 698     rv = EmcalLoader()->TreeP() ;
 699   }
 700
 701   return rv ;
 702 }
 703
 704 //____________________________________________________________________________
 705 TTree * AliEMCALGetter::TreeS() const
 706 {
 707   // return pointer to SDigits Tree
 708   TTree * rv = 0 ;
 709   rv = EmcalLoader()->TreeS() ;
 710   if ( !rv ) {
 711     EmcalLoader()->MakeTree("S");
 712     rv = EmcalLoader()->TreeS() ;
 713   }
 714
 715   return rv ;
 716 }
 717
 718 //____________________________________________________________________________
 719 Bool_t AliEMCALGetter::VersionExists(TString & opt) const
 720 {
 721   // checks if the version with the present name already exists in the same directory
 722
 723   Bool_t rv = kFALSE ;
 724
 725   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 726   TString version( rl->GetEventFolder()->GetName() ) ;
 727
 728   opt.ToLower() ;
 729
 730   if ( opt == "sdigits") {
 731     // add the version name to the root file name
 732     TString fileName( EmcalLoader()->GetSDigitsFileName() ) ;
 733     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
 734       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 735     if ( !(gSystem->AccessPathName(fileName)) ) {
 736       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 737       rv = kTRUE ;
 738     }
 739     EmcalLoader()->SetSDigitsFileName(fileName) ;
 740   }
 741
 742   if ( opt == "digits") {
 743     // add the version name to the root file name
 744     TString fileName( EmcalLoader()->GetDigitsFileName() ) ;
 745     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
 746       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 747     if ( !(gSystem->AccessPathName(fileName)) ) {
 748       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 749       rv = kTRUE ;
 750     }
 751     EmcalLoader()->SetDigitsFileName(fileName) ;
 752   }
 753
 754   return rv ;
 755
 756 }
 757
 758 //____________________________________________________________________________
 759 UShort_t AliEMCALGetter::EventPattern(void) const
 760 {
 761   // Return the pattern (trigger bit register) of the beam-test event
 762 //   if(fBTE)
 763 //     return fBTE->GetPattern() ;
 764 //   else
 765     return 0 ;
 766 }
 767 //____________________________________________________________________________
 768 Float_t AliEMCALGetter::BeamEnergy(void) const
 769 {
 770   // Return the beam energy of the beam-test event
 771 //   if(fBTE)
 772 //     return fBTE->GetBeamEnergy() ;
 773 //   else
 774     return 0 ;
 775 }