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