PHOS/AliPHOSGetter.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 AliPHOSAnalyser):
  28 //  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
  29 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
  30 //     AliPHOSRecParticle * 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 AliPHOSIndexToObject and make
  38 //*--         systematic usage of TFolders without changing the interface
  39 //////////////////////////////////////////////////////////////////////////////
  40
  41 // --- ROOT system ---
  42
  43 #include <TFile.h>
  44 #include <TROOT.h>
  45 #include <TSystem.h>
  46 #include <TParticle.h>
  47 #include <TF1.h>
  48 #include <TGraph.h>
  49 //#include <TCanvas.h>
  50 //#include <TFrame.h>
  51
  52 // --- Standard library ---
  53
  54 // --- AliRoot header files ---
  55 #include "AliESD.h"
  56 #include "AliHeader.h"
  57 #include "AliMC.h"
  58 #include "AliPHOS.h"
  59 #include "AliPHOSBeamTestEvent.h"
  60 #include "AliPHOSGetter.h"
  61 #include "AliPHOSLoader.h"
  62 #include "AliRunLoader.h"
  63 #include "AliStack.h"
  64 #include "AliPHOSRawStream.h"
  65 #include "AliRawReaderFile.h"
  66 #include "AliLog.h"
  67
  68 ClassImp(AliPHOSGetter)
  69
  70 AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
  71 AliPHOSLoader * AliPHOSGetter::fgPhosLoader = 0;
  72 Int_t AliPHOSGetter::fgDebug = 0;
  73
  74 //  TFile * AliPHOSGetter::fgFile = 0 ;
  75
  76 //____________________________________________________________________________
  77 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* version, Option_t * openingOption)
  78 {
  79   // ctor only called by Instance()
  80
  81   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ;
  82   if (!rl) {
  83     rl = AliRunLoader::Open(headerFile, version, openingOption);
  84     if (!rl) {
  85       Fatal("AliPHOSGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ;
  86       return ;
  87     }
  88     if (rl->GetAliRun() == 0x0) {
  89       rl->LoadgAlice();
  90       gAlice = rl->GetAliRun(); // should be removed
  91     }
  92   }
  93   fgPhosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
  94   if ( !fgPhosLoader )
  95     Error("AliPHOSGetter", "Could not find PHOSLoader") ;
  96   else
  97     fgPhosLoader->SetTitle(version);
  98
  99   // initialize data members
 100   SetDebug(0) ;
 101   fBTE = 0 ;
 102   fPrimaries = 0 ;
 103   fLoadingStatus = "" ;
 104
 105   fESDFileName = rl->GetFileName()  ; // this should be the galice.root file
 106   fESDFileName.ReplaceAll("galice.root", "AliESDs.root") ;
 107   fESDFile = 0 ;
 108   fESD = 0 ;
 109   fESDTree = 0 ;
 110   fRawDigits = kFALSE ;
 111 }
 112
 113 //____________________________________________________________________________
 114 AliPHOSGetter::~AliPHOSGetter()
 115 {
 116   // dtor
 117   if(fgPhosLoader){
 118     delete fgPhosLoader ;
 119     fgPhosLoader = 0 ;
 120   }
 121   if(fBTE){
 122     delete fBTE ;
 123     fBTE = 0 ;
 124   }
 125   if(fPrimaries){
 126     fPrimaries->Delete() ;
 127     delete fPrimaries ;
 128   }
 129   if (fESD)
 130     delete fESD ;
 131   if (fESDTree)
 132     delete fESDTree ;
 133
 134   fgObjGetter = 0;
 135 }
 136
 137 //____________________________________________________________________________
 138 void AliPHOSGetter::Reset()
 139 {
 140   // resets things in case the getter is called consecutively with different files
 141   // the PHOS Loader is already deleted by the Run Loader
 142
 143   if (fPrimaries) {
 144     fPrimaries->Delete() ;
 145     delete fPrimaries ;
 146   }
 147   fgPhosLoader = 0;
 148   fgObjGetter = 0;
 149 }
 150
 151 //____________________________________________________________________________
 152 AliPHOSClusterizer * AliPHOSGetter::Clusterizer()
 153 {
 154   // Returns pointer to the Clusterizer task
 155   AliPHOSClusterizer * rv ;
 156   rv =  dynamic_cast<AliPHOSClusterizer *>(PhosLoader()->Reconstructioner()) ;
 157   if (!rv) {
 158     Event(0, "R") ;
 159     rv =  dynamic_cast<AliPHOSClusterizer*>(PhosLoader()->Reconstructioner()) ;
 160   }
 161   return rv ;
 162 }
 163
 164 //____________________________________________________________________________
 165 TObjArray * AliPHOSGetter::CpvRecPoints()
 166 {
 167   // asks the Loader to return the CPV RecPoints container
 168
 169   TObjArray * rv = 0 ;
 170
 171   rv = PhosLoader()->CpvRecPoints() ;
 172   if (!rv) {
 173     PhosLoader()->MakeRecPointsArray() ;
 174     rv = PhosLoader()->CpvRecPoints() ;
 175   }
 176   return rv ;
 177 }
 178
 179 //____________________________________________________________________________
 180 TClonesArray * AliPHOSGetter::Digits()
 181 {
 182   // asks the Loader to return the Digits container
 183
 184   TClonesArray * rv = 0 ;
 185   rv = PhosLoader()->Digits() ;
 186
 187   if( !rv ) {
 188     PhosLoader()->MakeDigitsArray() ;
 189     rv = PhosLoader()->Digits() ;
 190   }
 191   return rv ;
 192 }
 193
 194 //____________________________________________________________________________
 195 AliPHOSDigitizer * AliPHOSGetter::Digitizer()
 196 {
 197   // Returns pointer to the Digitizer task
 198   AliPHOSDigitizer * rv ;
 199   rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
 200   if (!rv) {
 201     Event(0, "D") ;
 202     rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
 203   }
 204   return rv ;
 205 }
 206
 207
 208 //____________________________________________________________________________
 209 TObjArray * AliPHOSGetter::EmcRecPoints()
 210 {
 211   // asks the Loader to return the EMC RecPoints container
 212
 213   TObjArray * rv = 0 ;
 214
 215   rv = PhosLoader()->EmcRecPoints() ;
 216   if (!rv) {
 217     PhosLoader()->MakeRecPointsArray() ;
 218     rv = PhosLoader()->EmcRecPoints() ;
 219   }
 220   return rv ;
 221 }
 222
 223 //____________________________________________________________________________
 224 TClonesArray * AliPHOSGetter::TrackSegments()
 225 {
 226   // asks the Loader to return the TrackSegments container
 227
 228   TClonesArray * rv = 0 ;
 229
 230   rv = PhosLoader()->TrackSegments() ;
 231   if (!rv) {
 232     PhosLoader()->MakeTrackSegmentsArray() ;
 233     rv = PhosLoader()->TrackSegments() ;
 234   }
 235   return rv ;
 236 }
 237
 238 //____________________________________________________________________________
 239 AliPHOSTrackSegmentMaker * AliPHOSGetter::TrackSegmentMaker()
 240 {
 241   // Returns pointer to the TrackSegmentMaker task
 242   AliPHOSTrackSegmentMaker * rv ;
 243   rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
 244   if (!rv) {
 245     Event(0, "T") ;
 246     rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
 247   }
 248   return rv ;
 249 }
 250
 251 //____________________________________________________________________________
 252 TClonesArray * AliPHOSGetter::RecParticles()
 253 {
 254   // asks the Loader to return the TrackSegments container
 255
 256   TClonesArray * rv = 0 ;
 257
 258   rv = PhosLoader()->RecParticles() ;
 259   if (!rv) {
 260     PhosLoader()->MakeRecParticlesArray() ;
 261     rv = PhosLoader()->RecParticles() ;
 262   }
 263   return rv ;
 264 }
 265 //____________________________________________________________________________
 266 void AliPHOSGetter::Event(Int_t event, const char* opt)
 267 {
 268   // Reads the content of all Tree's S, D and R
 269
 270 //   if ( event >= MaxEvent() ) {
 271 //     Error("Event", "%d not found in TreeE !", event) ;
 272 //     return ;
 273 //   }
 274
 275   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 276
 277 //   // checks if we are dealing with test-beam data
 278 //   TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
 279 //   if(btb){
 280 //     if(!fBTE)
 281 //       fBTE = new AliPHOSBeamTestEvent() ;
 282 //     btb->SetAddress(&fBTE) ;
 283 //     btb->GetEntry(event) ;
 284 //   }
 285 //   else{
 286 //     if(fBTE){
 287 //       delete fBTE ;
 288 //       fBTE = 0 ;
 289 //     }
 290 //   }
 291
 292   // Loads the type of object(s) requested
 293
 294   rl->GetEvent(event) ;
 295
 296   if(strstr(opt,"X") || (strcmp(opt,"")==0)){
 297     ReadPrimaries() ;
 298   }
 299
 300   if(strstr(opt,"H")  ){
 301     ReadTreeH();
 302   }
 303
 304   if(strstr(opt,"S")  ){
 305     ReadTreeS() ;
 306   }
 307
 308   if(strstr(opt,"D") ){
 309     ReadTreeD() ;
 310   }
 311
 312   if(strstr(opt,"R") ){
 313     ReadTreeR() ;
 314   }
 315
 316   if( strstr(opt,"T") ){
 317     ReadTreeT() ;
 318   }
 319
 320   if( strstr(opt,"P") ){
 321     ReadTreeP() ;
 322   }
 323
 324   if( strstr(opt,"E") ){
 325     ReadTreeE(event) ;
 326   }
 327
 328 }
 329
 330
 331 //____________________________________________________________________________
 332 void AliPHOSGetter::Event(AliRawReader *rawReader, const char* opt)
 333 {
 334   // Reads the raw event from rawReader
 335
 336   if( strstr(opt,"W")  ){
 337     ReadRaw(rawReader) ;
 338   }
 339
 340 }
 341
 342
 343 //____________________________________________________________________________
 344 Int_t AliPHOSGetter::EventNumber() const
 345   {
 346   // return the current event number
 347   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 348   return static_cast<Int_t>(rl->GetEventNumber()) ;
 349 }
 350
 351 //____________________________________________________________________________
 352   TClonesArray * AliPHOSGetter::Hits()
 353 {
 354   // asks the loader to return  the Hits container
 355
 356   TClonesArray * rv = 0 ;
 357
 358   rv = PhosLoader()->Hits() ;
 359   if ( !rv ) {
 360     PhosLoader()->LoadHits("read");
 361     rv = PhosLoader()->Hits() ;
 362   }
 363   return rv ;
 364 }
 365
 366 //____________________________________________________________________________
 367 AliPHOSGetter * AliPHOSGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
 368 {
 369   // Creates and returns the pointer of the unique instance
 370   // Must be called only when the environment has changed
 371
 372   if(!fgObjGetter){ // first time the getter is called
 373     fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 374   }
 375   else { // the getter has been called previously
 376     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
 377     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
 378       // check if the file is already open
 379       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ;
 380
 381       if ( !galiceFile )
 382         fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 383
 384       else {  // the file is already open check the version name
 385         TString currentVersionName = rl->GetEventFolder()->GetName() ;
 386         TString newVersionName(version) ;
 387         if (currentVersionName == newVersionName)
 388           if(fgDebug)
 389             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;
 390         else {
 391           fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 392         }
 393       }
 394     }
 395     else {
 396       AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle()) ;
 397       if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
 398         delete rl ;
 399       fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 400     }
 401   }
 402   if (!fgObjGetter)
 403     ::Error("AliPHOSGetter::Instance", "Failed to create the PHOS Getter object") ;
 404   else
 405     if (fgDebug)
 406       Print() ;
 407
 408   return fgObjGetter ;
 409 }
 410
 411 //____________________________________________________________________________
 412 AliPHOSGetter *  AliPHOSGetter::Instance()
 413 {
 414   // Returns the pointer of the unique instance already defined
 415
 416   if(!fgObjGetter && fgDebug)
 417      ::Warning("AliPHOSGetter::Instance", "Getter not initialized") ;
 418
 419    return fgObjGetter ;
 420
 421 }
 422
 423 //____________________________________________________________________________
 424 Int_t AliPHOSGetter::MaxEvent() const
 425 {
 426   // returns the number of events in the run (from TE)
 427
 428   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 429   return static_cast<Int_t>(rl->GetNumberOfEvents()) ;
 430 }
 431
 432 //____________________________________________________________________________
 433 TParticle * AliPHOSGetter::Primary(Int_t index) const
 434 {
 435   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 436   return rl->Stack()->Particle(index) ;
 437 }
 438
 439 //____________________________________________________________________________
 440 AliPHOS * AliPHOSGetter:: PHOS() const
 441 {
 442   // returns the PHOS object
 443   AliPHOSLoader *    loader = 0;
 444   static AliPHOSLoader * oldloader = 0;
 445   static AliPHOS * phos = 0;
 446
 447   loader = PhosLoader();
 448
 449   if ( loader != oldloader) {
 450     phos = dynamic_cast<AliPHOS*>(loader->GetModulesFolder()->FindObject("PHOS")) ;
 451     oldloader = loader;
 452   }
 453   if (!phos)
 454     if (fgDebug)
 455       Warning("PHOS", "PHOS module not found in module folders: %s", PhosLoader()->GetModulesFolder()->GetName() ) ;
 456   return phos ;
 457 }
 458
 459
 460
 461 //____________________________________________________________________________
 462 AliPHOSPID * AliPHOSGetter::PID()
 463 {
 464   // Returns pointer to the PID task
 465   AliPHOSPID * rv ;
 466   rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
 467   if (!rv) {
 468     Event(0, "P") ;
 469     rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
 470   }
 471   return rv ;
 472 }
 473
 474 //____________________________________________________________________________
 475 AliPHOSGeometry * AliPHOSGetter::PHOSGeometry() const
 476 {
 477   // Returns PHOS geometry
 478
 479   AliPHOSGeometry * rv = 0 ;
 480   if (PHOS() )
 481     rv =  PHOS()->GetGeometry() ;
 482   return rv ;
 483 }
 484
 485 //____________________________________________________________________________
 486 TClonesArray * AliPHOSGetter::Primaries()
 487 {
 488   // creates the Primaries container if needed
 489   if ( !fPrimaries ) {
 490     if (fgDebug)
 491       Info("Primaries", "Creating a new TClonesArray for primaries") ;
 492     fPrimaries = new TClonesArray("TParticle", 1000) ;
 493   }
 494   return fPrimaries ;
 495 }
 496
 497 //____________________________________________________________________________
 498 void  AliPHOSGetter::Print()
 499 {
 500   // Print usefull information about the getter
 501
 502   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
 503   ::Info( "Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ;
 504 }
 505
 506 //____________________________________________________________________________
 507 void AliPHOSGetter::ReadPrimaries()
 508 {
 509   // Read Primaries from Kinematics.root
 510
 511   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 512
 513   // gets kine tree from the root file (Kinematics.root)
 514   if ( ! rl->TreeK() ) { // load treeK the first time
 515     rl->LoadKinematics() ;
 516   }
 517
 518   fNPrimaries = (rl->GetHeader())->GetNtrack();
 519   if (fgDebug)
 520     Info( "ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ;
 521
 522
 523   // first time creates the container
 524   if ( Primaries() )
 525     fPrimaries->Clear() ;
 526
 527   Int_t index = 0 ;
 528   for (index = 0 ; index < fNPrimaries; index++) {
 529     new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
 530   }
 531 }
 532
 533 //____________________________________________________________________________
 534 Bool_t AliPHOSGetter::OpenESDFile()
 535 {
 536   //Open the ESD file
 537   Bool_t rv = kTRUE ;
 538   if (!fESDFile) {
 539     fESDFile = TFile::Open(fESDFileName) ;
 540     if (!fESDFile )
 541       return kFALSE ;
 542   }
 543   else if (fESDFile->IsOpen()) {
 544     fESDFile->Close() ;
 545     fESDFile = TFile::Open(fESDFileName) ;
 546   }
 547   if (!fESDFile->IsOpen())
 548     rv = kFALSE ;
 549   return rv ;
 550 }
 551
 552 //____________________________________________________________________________
 553 Int_t AliPHOSGetter::ReadRaw(AliRawReader *rawReader)
 554 {
 555   // reads the raw format data, converts it into digits format and store digits in Digits()
 556   // container.
 557
 558   AliPHOSRawStream in(rawReader);
 559
 560   TClonesArray * digits = Digits() ;
 561   digits->Clear() ;
 562   Int_t idigit = 0 ;
 563
 564   while ( in.Next() ) { // PHOS entries loop
 565
 566     Int_t amp = in.GetSignal() ;
 567     Double_t time = in.GetTime() ;
 568     Int_t relId[4], id ;
 569
 570     relId[0] = in.GetModule() ;
 571     if ( relId[0] >= PHOS()->GetRawFormatLowGainOffset() ) {
 572       relId[0] -=  PHOS()->GetRawFormatLowGainOffset() ;
 573     }
 574     relId[1] = 0 ;
 575     relId[2] = in.GetRow() ;
 576     relId[3] = in.GetColumn() ;
 577     PHOSGeometry()->RelToAbsNumbering(relId, id) ;
 578
 579     if (amp > 0 && id >=0 ) {
 580       new((*digits)[idigit]) AliPHOSDigit( -1, id, amp, time) ;
 581       idigit++ ;
 582     }
 583
 584   } // PHOS entries loop
 585
 586   digits->Sort() ;
 587
 588   return digits->GetEntriesFast() ;
 589 }
 590 //____________________________________________________________________________
 591 Int_t AliPHOSGetter::ReadTreeD()
 592 {
 593   // Read the Digits
 594
 595   PhosLoader()->CleanDigits() ;
 596   PhosLoader()->LoadDigits("UPDATE") ;
 597   PhosLoader()->LoadDigitizer("UPDATE") ;
 598   return Digits()->GetEntries() ;
 599 }
 600
 601 //____________________________________________________________________________
 602 Int_t AliPHOSGetter::ReadTreeH()
 603 {
 604   // Read the Hits
 605   PhosLoader()->CleanHits() ;
 606   // gets TreeH from the root file (PHOS.Hit.root)
 607   //if ( !IsLoaded("H") ) {
 608     PhosLoader()->LoadHits("UPDATE") ;
 609   //  SetLoaded("H") ;
 610   //}
 611   return Hits()->GetEntries() ;
 612 }
 613
 614 //____________________________________________________________________________
 615 Int_t AliPHOSGetter::ReadTreeR()
 616 {
 617   // Read the RecPoints
 618
 619   PhosLoader()->CleanRecPoints() ;
 620   // gets TreeR from the root file (PHOS.RecPoints.root)
 621   //if ( !IsLoaded("R") ) {
 622     PhosLoader()->LoadRecPoints("UPDATE") ;
 623     PhosLoader()->LoadClusterizer("UPDATE") ;
 624     //  SetLoaded("R") ;
 625     //}
 626
 627   return EmcRecPoints()->GetEntries() ;
 628 }
 629
 630 //____________________________________________________________________________
 631 Int_t AliPHOSGetter::ReadTreeT()
 632 {
 633   // Read the TrackSegments
 634
 635   PhosLoader()->CleanTracks() ;
 636   // gets TreeT from the root file (PHOS.TrackSegments.root)
 637   //if ( !IsLoaded("T") ) {
 638     PhosLoader()->LoadTracks("UPDATE") ;
 639     PhosLoader()->LoadTrackSegmentMaker("UPDATE") ;
 640     //    SetLoaded("T") ;
 641     //}
 642
 643   return TrackSegments()->GetEntries() ;
 644 }
 645 //____________________________________________________________________________
 646 Int_t AliPHOSGetter::ReadTreeP()
 647 {
 648   // Read the RecParticles
 649
 650   PhosLoader()->CleanRecParticles() ;
 651
 652   // gets TreeT from the root file (PHOS.TrackSegments.root)
 653   //  if ( !IsLoaded("P") ) {
 654     PhosLoader()->LoadRecParticles("UPDATE") ;
 655     PhosLoader()->LoadPID("UPDATE") ;
 656     //  SetLoaded("P") ;
 657     //}
 658
 659   return RecParticles()->GetEntries() ;
 660 }
 661 //____________________________________________________________________________
 662 Int_t AliPHOSGetter::ReadTreeS()
 663 {
 664   // Read the SDigits
 665
 666   PhosLoader()->CleanSDigits() ;
 667   // gets TreeS from the root file (PHOS.SDigits.root)
 668   //if ( !IsLoaded("S") ) {
 669     PhosLoader()->LoadSDigits("READ") ;
 670     PhosLoader()->LoadSDigitizer("READ") ;
 671     //  SetLoaded("S") ;
 672     //}
 673
 674   return SDigits()->GetEntries() ;
 675 }
 676
 677 //____________________________________________________________________________
 678 Int_t AliPHOSGetter::ReadTreeE(Int_t event)
 679 {
 680   // Read the ESD
 681
 682   // gets esdTree from the root file (AliESDs.root)
 683   if (!fESDFile)
 684     if ( !OpenESDFile() )
 685       return -1 ;
 686
 687   fESDTree = static_cast<TTree*>(fESDFile->Get("esdTree")) ;
 688   fESD = new AliESD;
 689    if (!fESDTree) {
 690
 691      Error("ReadTreeE", "no ESD tree found");
 692      return -1;
 693    }
 694    fESDTree->SetBranchAddress("ESD", &fESD);
 695    fESDTree->GetEvent(event);
 696
 697    return event ;
 698 }
 699
 700 //____________________________________________________________________________
 701 TClonesArray * AliPHOSGetter::SDigits()
 702 {
 703   // asks the Loader to return the Digits container
 704
 705   TClonesArray * rv = 0 ;
 706
 707   rv = PhosLoader()->SDigits() ;
 708   if (!rv) {
 709     PhosLoader()->MakeSDigitsArray() ;
 710     rv = PhosLoader()->SDigits() ;
 711   }
 712   return rv ;
 713 }
 714
 715 //____________________________________________________________________________
 716 AliPHOSSDigitizer * AliPHOSGetter::SDigitizer()
 717 {
 718   // Returns pointer to the SDigitizer task
 719   AliPHOSSDigitizer * rv ;
 720   rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 721   if (!rv) {
 722     Event(0, "S") ;
 723     rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 724   }
 725   return rv ;
 726 }
 727
 728 //____________________________________________________________________________
 729 TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
 730 {
 731   // Return first (index=1) or second (index=2) secondary particle of primary particle p
 732
 733   if(index <= 0)
 734     return 0 ;
 735   if(index > 2)
 736     return 0 ;
 737
 738   if(p) {
 739   Int_t daughterIndex = p->GetDaughter(index-1) ;
 740   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 741   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
 742   }
 743   else
 744     return 0 ;
 745 }
 746
 747 //____________________________________________________________________________
 748 void AliPHOSGetter::Track(Int_t itrack)
 749 {
 750   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
 751
 752  AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 753
 754   if( !TreeH() ) // load treeH the first time
 755     rl->LoadHits() ;
 756
 757   // first time create the container
 758   TClonesArray * hits = Hits() ;
 759   if ( hits )
 760     hits->Clear() ;
 761
 762   TBranch * phosbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("PHOS")) ;
 763   phosbranch->SetAddress(&hits) ;
 764   phosbranch->GetEntry(itrack) ;
 765 }
 766
 767 //____________________________________________________________________________
 768 TTree * AliPHOSGetter::TreeD() const
 769 {
 770   // Returns pointer to the Digits Tree
 771   TTree * rv = 0 ;
 772   rv = PhosLoader()->TreeD() ;
 773   if ( !rv ) {
 774     PhosLoader()->MakeTree("D");
 775     rv = PhosLoader()->TreeD() ;
 776   }
 777
 778   return rv ;
 779 }
 780
 781 //____________________________________________________________________________
 782 TTree * AliPHOSGetter::TreeH() const
 783 {
 784   // Returns pointer to the Hits Tree
 785   TTree * rv = 0 ;
 786   rv = PhosLoader()->TreeH() ;
 787   if ( !rv ) {
 788     PhosLoader()->MakeTree("H");
 789     rv = PhosLoader()->TreeH() ;
 790   }
 791
 792   return rv ;
 793 }
 794
 795 //____________________________________________________________________________
 796 TTree * AliPHOSGetter::TreeR() const
 797 {
 798   // Returns pointer to the RecPoints Tree
 799   TTree * rv = 0 ;
 800   rv = PhosLoader()->TreeR() ;
 801   if ( !rv ) {
 802     PhosLoader()->MakeTree("R");
 803     rv = PhosLoader()->TreeR() ;
 804   }
 805
 806   return rv ;
 807 }
 808
 809 //____________________________________________________________________________
 810 TTree * AliPHOSGetter::TreeT() const
 811 {
 812   // Returns pointer to the TrackSegments Tree
 813   TTree * rv = 0 ;
 814   rv = PhosLoader()->TreeT() ;
 815   if ( !rv ) {
 816     PhosLoader()->MakeTree("T");
 817     rv = PhosLoader()->TreeT() ;
 818   }
 819
 820   return rv ;
 821 }
 822 //____________________________________________________________________________
 823 TTree * AliPHOSGetter::TreeP() const
 824 {
 825   // Returns pointer to the RecParticles  Tree
 826   TTree * rv = 0 ;
 827   rv = PhosLoader()->TreeP() ;
 828   if ( !rv ) {
 829     PhosLoader()->MakeTree("P");
 830     rv = PhosLoader()->TreeP() ;
 831   }
 832
 833   return rv ;
 834 }
 835
 836 //____________________________________________________________________________
 837 TTree * AliPHOSGetter::TreeS() const
 838 {
 839  // Returns pointer to the SDigits Tree
 840   TTree * rv = 0 ;
 841   rv = PhosLoader()->TreeS() ;
 842   if ( !rv ) {
 843     PhosLoader()->MakeTree("S");
 844     rv = PhosLoader()->TreeS() ;
 845   }
 846
 847   return rv ;
 848 }
 849
 850 //____________________________________________________________________________
 851 Bool_t AliPHOSGetter::VersionExists(TString & opt) const
 852 {
 853   // checks if the version with the present name already exists in the same directory
 854
 855   Bool_t rv = kFALSE ;
 856
 857   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 858   TString version( rl->GetEventFolder()->GetName() ) ;
 859
 860   opt.ToLower() ;
 861
 862   if ( opt == "sdigits") {
 863     // add the version name to the root file name
 864     TString fileName( PhosLoader()->GetSDigitsFileName() ) ;
 865     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 866       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 867     if ( !(gSystem->AccessPathName(fileName)) ) {
 868       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 869       rv = kTRUE ;
 870     }
 871     PhosLoader()->SetSDigitsFileName(fileName) ;
 872   }
 873
 874   if ( opt == "digits") {
 875     // add the version name to the root file name
 876     TString fileName( PhosLoader()->GetDigitsFileName() ) ;
 877     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 878       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 879     if ( !(gSystem->AccessPathName(fileName)) ) {
 880       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 881       rv = kTRUE ;
 882     }
 883   }
 884
 885   return rv ;
 886
 887 }
 888
 889 //____________________________________________________________________________
 890 UShort_t AliPHOSGetter::EventPattern(void) const
 891 {
 892   // Return the pattern (trigger bit register) of the beam-test event
 893   if(fBTE)
 894     return fBTE->GetPattern() ;
 895   else
 896     return 0 ;
 897 }
 898 //____________________________________________________________________________
 899 Float_t AliPHOSGetter::BeamEnergy(void) const
 900 {
 901   // Return the beam energy of the beam-test event
 902   if(fBTE)
 903     return fBTE->GetBeamEnergy() ;
 904   else
 905     return 0 ;
 906 }