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 <TH1D.h>
  48 #include <TF1.h>
  49 #include <TGraph.h>
  50 //#include <TCanvas.h>
  51 #include <TFrame.h>
  52
  53 // --- Standard library ---
  54
  55 // --- AliRoot header files ---
  56 #include "AliESD.h"
  57 #include "AliHeader.h"
  58 #include "AliMC.h"
  59 #include "AliPHOS.h"
  60 #include "AliPHOSBeamTestEvent.h"
  61 #include "AliPHOSGetter.h"
  62 #include "AliPHOSLoader.h"
  63 #include "AliRunLoader.h"
  64 #include "AliStack.h"
  65 #include "AliPHOSRawStream.h"
  66 #include "AliRawReaderFile.h"
  67 #include "AliLog.h"
  68
  69 ClassImp(AliPHOSGetter)
  70
  71 AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
  72 AliPHOSLoader * AliPHOSGetter::fgPhosLoader = 0;
  73 Int_t AliPHOSGetter::fgDebug = 0;
  74
  75 //  TFile * AliPHOSGetter::fgFile = 0 ;
  76
  77 //____________________________________________________________________________
  78 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* version, Option_t * openingOption)
  79 {
  80   // ctor only called by Instance()
  81
  82   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ;
  83   if (!rl) {
  84     rl = AliRunLoader::Open(headerFile, version, openingOption);
  85     if (!rl) {
  86       Fatal("AliPHOSGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ;
  87       return ;
  88     }
  89     if (rl->GetAliRun() == 0x0) {
  90       rl->LoadgAlice();
  91       gAlice = rl->GetAliRun(); // should be removed
  92     }
  93   }
  94   fgPhosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
  95   if ( !fgPhosLoader )
  96     Error("AliPHOSGetter", "Could not find PHOSLoader") ;
  97   else
  98     fgPhosLoader->SetTitle(version);
  99
 100   // initialize data members
 101   SetDebug(0) ;
 102   fBTE = 0 ;
 103   fPrimaries = 0 ;
 104   fLoadingStatus = "" ;
 105
 106   fESDFileName = rl->GetFileName()  ; // this should be the galice.root file
 107   fESDFileName.ReplaceAll("galice.root", "AliESDs.root") ;
 108   fESDFile = 0 ;
 109   fESD = 0 ;
 110   fESDTree = 0 ;
 111   fRawDigits = kFALSE ;
 112 }
 113
 114 //____________________________________________________________________________
 115 AliPHOSGetter::~AliPHOSGetter()
 116 {
 117   // dtor
 118   if(fgPhosLoader){
 119     delete fgPhosLoader ;
 120     fgPhosLoader = 0 ;
 121   }
 122   if(fBTE){
 123     delete fBTE ;
 124     fBTE = 0 ;
 125   }
 126   if(fPrimaries){
 127     fPrimaries->Delete() ;
 128     delete fPrimaries ;
 129   }
 130   if (fESD)
 131     delete fESD ;
 132   if (fESDTree)
 133     delete fESDTree ;
 134
 135   //  fgObjGetter = 0;
 136 }
 137
 138 //____________________________________________________________________________
 139 void AliPHOSGetter::Reset()
 140 {
 141   // resets things in case the getter is called consecutively with different files
 142   // the PHOS Loader is already deleted by the Run Loader
 143
 144   if (fPrimaries) {
 145     fPrimaries->Delete() ;
 146     delete fPrimaries ;
 147   }
 148   fgPhosLoader = 0;
 149   fgObjGetter = 0;
 150 }
 151
 152 //____________________________________________________________________________
 153 AliPHOSClusterizer * AliPHOSGetter::Clusterizer()
 154 {
 155   // Returns pointer to the Clusterizer task
 156   AliPHOSClusterizer * rv ;
 157   rv =  dynamic_cast<AliPHOSClusterizer *>(PhosLoader()->Reconstructioner()) ;
 158   if (!rv) {
 159     Event(0, "R") ;
 160     rv =  dynamic_cast<AliPHOSClusterizer*>(PhosLoader()->Reconstructioner()) ;
 161   }
 162   return rv ;
 163 }
 164
 165 //____________________________________________________________________________
 166 TObjArray * AliPHOSGetter::CpvRecPoints()
 167 {
 168   // asks the Loader to return the CPV RecPoints container
 169
 170   TObjArray * rv = 0 ;
 171
 172   rv = PhosLoader()->CpvRecPoints() ;
 173   if (!rv) {
 174     PhosLoader()->MakeRecPointsArray() ;
 175     rv = PhosLoader()->CpvRecPoints() ;
 176   }
 177   return rv ;
 178 }
 179
 180 //____________________________________________________________________________
 181 TClonesArray * AliPHOSGetter::Digits()
 182 {
 183   // asks the Loader to return the Digits container
 184
 185   TClonesArray * rv = 0 ;
 186   rv = PhosLoader()->Digits() ;
 187
 188   if( !rv ) {
 189     PhosLoader()->MakeDigitsArray() ;
 190     rv = PhosLoader()->Digits() ;
 191   }
 192   return rv ;
 193 }
 194
 195 //____________________________________________________________________________
 196 AliPHOSDigitizer * AliPHOSGetter::Digitizer()
 197 {
 198   // Returns pointer to the Digitizer task
 199   AliPHOSDigitizer * rv ;
 200   rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
 201   if (!rv) {
 202     Event(0, "D") ;
 203     rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
 204   }
 205   return rv ;
 206 }
 207
 208
 209 //____________________________________________________________________________
 210 TObjArray * AliPHOSGetter::EmcRecPoints()
 211 {
 212   // asks the Loader to return the EMC RecPoints container
 213
 214   TObjArray * rv = 0 ;
 215
 216   rv = PhosLoader()->EmcRecPoints() ;
 217   if (!rv) {
 218     PhosLoader()->MakeRecPointsArray() ;
 219     rv = PhosLoader()->EmcRecPoints() ;
 220   }
 221   return rv ;
 222 }
 223
 224 //____________________________________________________________________________
 225 TClonesArray * AliPHOSGetter::TrackSegments()
 226 {
 227   // asks the Loader to return the TrackSegments container
 228
 229   TClonesArray * rv = 0 ;
 230
 231   rv = PhosLoader()->TrackSegments() ;
 232   if (!rv) {
 233     PhosLoader()->MakeTrackSegmentsArray() ;
 234     rv = PhosLoader()->TrackSegments() ;
 235   }
 236   return rv ;
 237 }
 238
 239 //____________________________________________________________________________
 240 AliPHOSTrackSegmentMaker * AliPHOSGetter::TrackSegmentMaker()
 241 {
 242   // Returns pointer to the TrackSegmentMaker task
 243   AliPHOSTrackSegmentMaker * rv ;
 244   rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
 245   if (!rv) {
 246     Event(0, "T") ;
 247     rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
 248   }
 249   return rv ;
 250 }
 251
 252 //____________________________________________________________________________
 253 TClonesArray * AliPHOSGetter::RecParticles()
 254 {
 255   // asks the Loader to return the TrackSegments container
 256
 257   TClonesArray * rv = 0 ;
 258
 259   rv = PhosLoader()->RecParticles() ;
 260   if (!rv) {
 261     PhosLoader()->MakeRecParticlesArray() ;
 262     rv = PhosLoader()->RecParticles() ;
 263   }
 264   return rv ;
 265 }
 266 //____________________________________________________________________________
 267 void AliPHOSGetter::Event(Int_t event, const char* opt)
 268 {
 269   // Reads the content of all Tree's S, D and R
 270
 271 //   if ( event >= MaxEvent() ) {
 272 //     Error("Event", "%d not found in TreeE !", event) ;
 273 //     return ;
 274 //   }
 275
 276   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 277
 278 //   // checks if we are dealing with test-beam data
 279 //   TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
 280 //   if(btb){
 281 //     if(!fBTE)
 282 //       fBTE = new AliPHOSBeamTestEvent() ;
 283 //     btb->SetAddress(&fBTE) ;
 284 //     btb->GetEntry(event) ;
 285 //   }
 286 //   else{
 287 //     if(fBTE){
 288 //       delete fBTE ;
 289 //       fBTE = 0 ;
 290 //     }
 291 //   }
 292
 293   // Loads the type of object(s) requested
 294
 295   rl->GetEvent(event) ;
 296
 297   if(strstr(opt,"X") || (strcmp(opt,"")==0)){
 298     ReadPrimaries() ;
 299   }
 300
 301   if(strstr(opt,"H")  ){
 302     ReadTreeH();
 303   }
 304
 305   if(strstr(opt,"S")  ){
 306     ReadTreeS() ;
 307   }
 308
 309   if(strstr(opt,"D") ){
 310     ReadTreeD() ;
 311   }
 312
 313   if(strstr(opt,"R") ){
 314     ReadTreeR() ;
 315   }
 316
 317   if( strstr(opt,"T") ){
 318     ReadTreeT() ;
 319   }
 320
 321   if( strstr(opt,"P") ){
 322     ReadTreeP() ;
 323   }
 324
 325   if( strstr(opt,"E") ){
 326     ReadTreeE(event) ;
 327   }
 328
 329 if( strstr(opt,"W")  ){
 330     ReadRaw(event) ;
 331   }
 332
 333
 334 //   if( strstr(opt,"Q")   && (fCurentEvent[9]!=event) )
 335 //     ReadTreeQA() ;
 336 //   }
 337
 338 }
 339
 340
 341 //____________________________________________________________________________
 342 Int_t AliPHOSGetter::EventNumber() const
 343   {
 344   // return the current event number
 345   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 346   return static_cast<Int_t>(rl->GetEventNumber()) ;
 347 }
 348
 349 //____________________________________________________________________________
 350   TClonesArray * AliPHOSGetter::Hits()
 351 {
 352   // asks the loader to return  the Hits container
 353
 354   TClonesArray * rv = 0 ;
 355
 356   rv = PhosLoader()->Hits() ;
 357   if ( !rv ) {
 358     PhosLoader()->LoadHits("read");
 359     rv = PhosLoader()->Hits() ;
 360   }
 361   return rv ;
 362 }
 363
 364 //____________________________________________________________________________
 365 AliPHOSGetter * AliPHOSGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
 366 {
 367   // Creates and returns the pointer of the unique instance
 368   // Must be called only when the environment has changed
 369
 370   //::Info("Instance","alirunFileName=%s version=%s openingOption=%s",alirunFileName,version,openingOption);
 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(Int_t event)
 554 {
 555   // reads the raw format data, converts it into digits format and store digits in Digits()
 556   // container.
 557
 558   AliRawReaderFile rawReader(event) ;
 559   AliPHOSRawStream in(&rawReader);
 560
 561   TClonesArray * digits = Digits() ;
 562   digits->Clear() ;
 563   Int_t idigit = 0 ;
 564
 565   while ( in.Next() ) { // PHOS entries loop
 566
 567     Int_t amp = in.GetSignal() ;
 568     Double_t time = in.GetTime() ;
 569     Int_t relId[4], id ;
 570
 571     relId[0] = in.GetModule() ;
 572     if ( relId[0] >= PHOS()->GetRawFormatLowGainOffset() ) {
 573       relId[0] -=  PHOS()->GetRawFormatLowGainOffset() ;
 574     }
 575     relId[1] = 0 ;
 576     relId[2] = in.GetRow() ;
 577     relId[3] = in.GetColumn() ;
 578     PHOSGeometry()->RelToAbsNumbering(relId, id) ;
 579
 580     if (amp > 0 && id >=0 ) {
 581       new((*digits)[idigit]) AliPHOSDigit( -1, id, amp, time) ;
 582       idigit++ ;
 583     }
 584
 585   } // PHOS entries loop
 586
 587   digits->Sort() ;
 588
 589   return digits->GetEntriesFast() ;
 590 }
 591 //____________________________________________________________________________
 592 Int_t AliPHOSGetter::ReadTreeD()
 593 {
 594   // Read the Digits
 595
 596   PhosLoader()->CleanDigits() ;
 597   PhosLoader()->LoadDigits("UPDATE") ;
 598   PhosLoader()->LoadDigitizer("UPDATE") ;
 599   return Digits()->GetEntries() ;
 600 }
 601
 602 //____________________________________________________________________________
 603 Int_t AliPHOSGetter::ReadTreeH()
 604 {
 605   // Read the Hits
 606   PhosLoader()->CleanHits() ;
 607   // gets TreeH from the root file (PHOS.Hit.root)
 608   //if ( !IsLoaded("H") ) {
 609     PhosLoader()->LoadHits("UPDATE") ;
 610   //  SetLoaded("H") ;
 611   //}
 612   return Hits()->GetEntries() ;
 613 }
 614
 615 //____________________________________________________________________________
 616 Int_t AliPHOSGetter::ReadTreeR()
 617 {
 618   // Read the RecPoints
 619
 620   PhosLoader()->CleanRecPoints() ;
 621   // gets TreeR from the root file (PHOS.RecPoints.root)
 622   //if ( !IsLoaded("R") ) {
 623     PhosLoader()->LoadRecPoints("UPDATE") ;
 624     PhosLoader()->LoadClusterizer("UPDATE") ;
 625     //  SetLoaded("R") ;
 626     //}
 627
 628   return EmcRecPoints()->GetEntries() ;
 629 }
 630
 631 //____________________________________________________________________________
 632 Int_t AliPHOSGetter::ReadTreeT()
 633 {
 634   // Read the TrackSegments
 635
 636   PhosLoader()->CleanTracks() ;
 637   // gets TreeT from the root file (PHOS.TrackSegments.root)
 638   //if ( !IsLoaded("T") ) {
 639     PhosLoader()->LoadTracks("UPDATE") ;
 640     PhosLoader()->LoadTrackSegmentMaker("UPDATE") ;
 641     //    SetLoaded("T") ;
 642     //}
 643
 644   return TrackSegments()->GetEntries() ;
 645 }
 646 //____________________________________________________________________________
 647 Int_t AliPHOSGetter::ReadTreeP()
 648 {
 649   // Read the RecParticles
 650
 651   PhosLoader()->CleanRecParticles() ;
 652
 653   // gets TreeT from the root file (PHOS.TrackSegments.root)
 654   //  if ( !IsLoaded("P") ) {
 655     PhosLoader()->LoadRecParticles("UPDATE") ;
 656     PhosLoader()->LoadPID("UPDATE") ;
 657     //  SetLoaded("P") ;
 658     //}
 659
 660   return RecParticles()->GetEntries() ;
 661 }
 662 //____________________________________________________________________________
 663 Int_t AliPHOSGetter::ReadTreeS()
 664 {
 665   // Read the SDigits
 666
 667   PhosLoader()->CleanSDigits() ;
 668   // gets TreeS from the root file (PHOS.SDigits.root)
 669   //if ( !IsLoaded("S") ) {
 670     PhosLoader()->LoadSDigits("READ") ;
 671     PhosLoader()->LoadSDigitizer("READ") ;
 672     //  SetLoaded("S") ;
 673     //}
 674
 675   return SDigits()->GetEntries() ;
 676 }
 677
 678 //____________________________________________________________________________
 679 Int_t AliPHOSGetter::ReadTreeE(Int_t event)
 680 {
 681   // Read the ESD
 682
 683   // gets esdTree from the root file (AliESDs.root)
 684   if (!fESDFile)
 685     if ( !OpenESDFile() )
 686       return -1 ;
 687
 688   fESDTree = static_cast<TTree*>(fESDFile->Get("esdTree")) ;
 689   fESD = new AliESD;
 690    if (!fESDTree) {
 691
 692      Error("ReadTreeE", "no ESD tree found");
 693      return -1;
 694    }
 695    fESDTree->SetBranchAddress("ESD", &fESD);
 696    fESDTree->GetEvent(event);
 697
 698    return event ;
 699 }
 700
 701 //____________________________________________________________________________
 702 TClonesArray * AliPHOSGetter::SDigits()
 703 {
 704   // asks the Loader to return the Digits container
 705
 706   TClonesArray * rv = 0 ;
 707
 708   rv = PhosLoader()->SDigits() ;
 709   if (!rv) {
 710     PhosLoader()->MakeSDigitsArray() ;
 711     rv = PhosLoader()->SDigits() ;
 712   }
 713   return rv ;
 714 }
 715
 716 //____________________________________________________________________________
 717 AliPHOSSDigitizer * AliPHOSGetter::SDigitizer()
 718 {
 719   // Returns pointer to the SDigitizer task
 720   AliPHOSSDigitizer * rv ;
 721   rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 722   if (!rv) {
 723     Event(0, "S") ;
 724     rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 725   }
 726   return rv ;
 727 }
 728
 729 //____________________________________________________________________________
 730 TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
 731 {
 732   // Return first (index=1) or second (index=2) secondary particle of primary particle p
 733
 734   if(index <= 0)
 735     return 0 ;
 736   if(index > 2)
 737     return 0 ;
 738
 739   if(p) {
 740   Int_t daughterIndex = p->GetDaughter(index-1) ;
 741   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 742   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
 743   }
 744   else
 745     return 0 ;
 746 }
 747
 748 //____________________________________________________________________________
 749 void AliPHOSGetter::Track(Int_t itrack)
 750 {
 751   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
 752
 753  AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 754
 755   if( !TreeH() ) // load treeH the first time
 756     rl->LoadHits() ;
 757
 758   // first time create the container
 759   TClonesArray * hits = Hits() ;
 760   if ( hits )
 761     hits->Clear() ;
 762
 763   TBranch * phosbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("PHOS")) ;
 764   phosbranch->SetAddress(&hits) ;
 765   phosbranch->GetEntry(itrack) ;
 766 }
 767
 768 //____________________________________________________________________________
 769 TTree * AliPHOSGetter::TreeD() const
 770 {
 771   // Returns pointer to the Digits Tree
 772   TTree * rv = 0 ;
 773   rv = PhosLoader()->TreeD() ;
 774   if ( !rv ) {
 775     PhosLoader()->MakeTree("D");
 776     rv = PhosLoader()->TreeD() ;
 777   }
 778
 779   return rv ;
 780 }
 781
 782 //____________________________________________________________________________
 783 TTree * AliPHOSGetter::TreeH() const
 784 {
 785   // Returns pointer to the Hits Tree
 786   TTree * rv = 0 ;
 787   rv = PhosLoader()->TreeH() ;
 788   if ( !rv ) {
 789     PhosLoader()->MakeTree("H");
 790     rv = PhosLoader()->TreeH() ;
 791   }
 792
 793   return rv ;
 794 }
 795
 796 //____________________________________________________________________________
 797 TTree * AliPHOSGetter::TreeR() const
 798 {
 799   // Returns pointer to the RecPoints Tree
 800   TTree * rv = 0 ;
 801   rv = PhosLoader()->TreeR() ;
 802   if ( !rv ) {
 803     PhosLoader()->MakeTree("R");
 804     rv = PhosLoader()->TreeR() ;
 805   }
 806
 807   return rv ;
 808 }
 809
 810 //____________________________________________________________________________
 811 TTree * AliPHOSGetter::TreeT() const
 812 {
 813   // Returns pointer to the TrackSegments Tree
 814   TTree * rv = 0 ;
 815   rv = PhosLoader()->TreeT() ;
 816   if ( !rv ) {
 817     PhosLoader()->MakeTree("T");
 818     rv = PhosLoader()->TreeT() ;
 819   }
 820
 821   return rv ;
 822 }
 823 //____________________________________________________________________________
 824 TTree * AliPHOSGetter::TreeP() const
 825 {
 826   // Returns pointer to the RecParticles  Tree
 827   TTree * rv = 0 ;
 828   rv = PhosLoader()->TreeP() ;
 829   if ( !rv ) {
 830     PhosLoader()->MakeTree("P");
 831     rv = PhosLoader()->TreeP() ;
 832   }
 833
 834   return rv ;
 835 }
 836
 837 //____________________________________________________________________________
 838 TTree * AliPHOSGetter::TreeS() const
 839 {
 840  // Returns pointer to the SDigits Tree
 841   TTree * rv = 0 ;
 842   rv = PhosLoader()->TreeS() ;
 843   if ( !rv ) {
 844     PhosLoader()->MakeTree("S");
 845     rv = PhosLoader()->TreeS() ;
 846   }
 847
 848   return rv ;
 849 }
 850
 851 //____________________________________________________________________________
 852 Bool_t AliPHOSGetter::VersionExists(TString & opt) const
 853 {
 854   // checks if the version with the present name already exists in the same directory
 855
 856   Bool_t rv = kFALSE ;
 857
 858   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 859   TString version( rl->GetEventFolder()->GetName() ) ;
 860
 861   opt.ToLower() ;
 862
 863   if ( opt == "sdigits") {
 864     // add the version name to the root file name
 865     TString fileName( PhosLoader()->GetSDigitsFileName() ) ;
 866     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 867       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 868     if ( !(gSystem->AccessPathName(fileName)) ) {
 869       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 870       rv = kTRUE ;
 871     }
 872     PhosLoader()->SetSDigitsFileName(fileName) ;
 873   }
 874
 875   if ( opt == "digits") {
 876     // add the version name to the root file name
 877     TString fileName( PhosLoader()->GetDigitsFileName() ) ;
 878     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 879       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 880     if ( !(gSystem->AccessPathName(fileName)) ) {
 881       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 882       rv = kTRUE ;
 883     }
 884   }
 885
 886   return rv ;
 887
 888 }
 889
 890 //____________________________________________________________________________
 891 UShort_t AliPHOSGetter::EventPattern(void) const
 892 {
 893   // Return the pattern (trigger bit register) of the beam-test event
 894   if(fBTE)
 895     return fBTE->GetPattern() ;
 896   else
 897     return 0 ;
 898 }
 899 //____________________________________________________________________________
 900 Float_t AliPHOSGetter::BeamEnergy(void) const
 901 {
 902   // Return the beam energy of the beam-test event
 903   if(fBTE)
 904     return fBTE->GetBeamEnergy() ;
 905   else
 906     return 0 ;
 907 }