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 if( strstr(opt,"W")  ){
 329     ReadRaw(event) ;
 330   }
 331
 332 }
 333
 334
 335 //____________________________________________________________________________
 336 Int_t AliPHOSGetter::EventNumber() const
 337   {
 338   // return the current event number
 339   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 340   return static_cast<Int_t>(rl->GetEventNumber()) ;
 341 }
 342
 343 //____________________________________________________________________________
 344   TClonesArray * AliPHOSGetter::Hits()
 345 {
 346   // asks the loader to return  the Hits container
 347
 348   TClonesArray * rv = 0 ;
 349
 350   rv = PhosLoader()->Hits() ;
 351   if ( !rv ) {
 352     PhosLoader()->LoadHits("read");
 353     rv = PhosLoader()->Hits() ;
 354   }
 355   return rv ;
 356 }
 357
 358 //____________________________________________________________________________
 359 AliPHOSGetter * AliPHOSGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption)
 360 {
 361   // Creates and returns the pointer of the unique instance
 362   // Must be called only when the environment has changed
 363
 364   //::Info("Instance","alirunFileName=%s version=%s openingOption=%s",alirunFileName,version,openingOption);
 365
 366   if(!fgObjGetter){ // first time the getter is called
 367     fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 368   }
 369   else { // the getter has been called previously
 370     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
 371     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
 372       // check if the file is already open
 373       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ;
 374
 375       if ( !galiceFile )
 376         fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 377
 378       else {  // the file is already open check the version name
 379         TString currentVersionName = rl->GetEventFolder()->GetName() ;
 380         TString newVersionName(version) ;
 381         if (currentVersionName == newVersionName)
 382           if(fgDebug)
 383             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;
 384         else {
 385           fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 386         }
 387       }
 388     }
 389     else {
 390       AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle()) ;
 391       if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
 392         delete rl ;
 393       fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
 394     }
 395   }
 396   if (!fgObjGetter)
 397     ::Error("AliPHOSGetter::Instance", "Failed to create the PHOS Getter object") ;
 398   else
 399     if (fgDebug)
 400       Print() ;
 401
 402   return fgObjGetter ;
 403 }
 404
 405 //____________________________________________________________________________
 406 AliPHOSGetter *  AliPHOSGetter::Instance()
 407 {
 408   // Returns the pointer of the unique instance already defined
 409
 410   if(!fgObjGetter && fgDebug)
 411      ::Warning("AliPHOSGetter::Instance", "Getter not initialized") ;
 412
 413    return fgObjGetter ;
 414
 415 }
 416
 417 //____________________________________________________________________________
 418 Int_t AliPHOSGetter::MaxEvent() const
 419 {
 420   // returns the number of events in the run (from TE)
 421
 422   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 423   return static_cast<Int_t>(rl->GetNumberOfEvents()) ;
 424 }
 425
 426 //____________________________________________________________________________
 427 TParticle * AliPHOSGetter::Primary(Int_t index) const
 428 {
 429   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 430   return rl->Stack()->Particle(index) ;
 431 }
 432
 433 //____________________________________________________________________________
 434 AliPHOS * AliPHOSGetter:: PHOS() const
 435 {
 436   // returns the PHOS object
 437   AliPHOSLoader *    loader = 0;
 438   static AliPHOSLoader * oldloader = 0;
 439   static AliPHOS * phos = 0;
 440
 441   loader = PhosLoader();
 442
 443   if ( loader != oldloader) {
 444     phos = dynamic_cast<AliPHOS*>(loader->GetModulesFolder()->FindObject("PHOS")) ;
 445     oldloader = loader;
 446   }
 447   if (!phos)
 448     if (fgDebug)
 449       Warning("PHOS", "PHOS module not found in module folders: %s", PhosLoader()->GetModulesFolder()->GetName() ) ;
 450   return phos ;
 451 }
 452
 453
 454
 455 //____________________________________________________________________________
 456 AliPHOSPID * AliPHOSGetter::PID()
 457 {
 458   // Returns pointer to the PID task
 459   AliPHOSPID * rv ;
 460   rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
 461   if (!rv) {
 462     Event(0, "P") ;
 463     rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
 464   }
 465   return rv ;
 466 }
 467
 468 //____________________________________________________________________________
 469 AliPHOSGeometry * AliPHOSGetter::PHOSGeometry() const
 470 {
 471   // Returns PHOS geometry
 472
 473   AliPHOSGeometry * rv = 0 ;
 474   if (PHOS() )
 475     rv =  PHOS()->GetGeometry() ;
 476   return rv ;
 477 }
 478
 479 //____________________________________________________________________________
 480 TClonesArray * AliPHOSGetter::Primaries()
 481 {
 482   // creates the Primaries container if needed
 483   if ( !fPrimaries ) {
 484     if (fgDebug)
 485       Info("Primaries", "Creating a new TClonesArray for primaries") ;
 486     fPrimaries = new TClonesArray("TParticle", 1000) ;
 487   }
 488   return fPrimaries ;
 489 }
 490
 491 //____________________________________________________________________________
 492 void  AliPHOSGetter::Print()
 493 {
 494   // Print usefull information about the getter
 495
 496   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
 497   ::Info( "Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ;
 498 }
 499
 500 //____________________________________________________________________________
 501 void AliPHOSGetter::ReadPrimaries()
 502 {
 503   // Read Primaries from Kinematics.root
 504
 505   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 506
 507   // gets kine tree from the root file (Kinematics.root)
 508   if ( ! rl->TreeK() ) { // load treeK the first time
 509     rl->LoadKinematics() ;
 510   }
 511
 512   fNPrimaries = (rl->GetHeader())->GetNtrack();
 513   if (fgDebug)
 514     Info( "ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ;
 515
 516
 517   // first time creates the container
 518   if ( Primaries() )
 519     fPrimaries->Clear() ;
 520
 521   Int_t index = 0 ;
 522   for (index = 0 ; index < fNPrimaries; index++) {
 523     new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
 524   }
 525 }
 526
 527 //____________________________________________________________________________
 528 Bool_t AliPHOSGetter::OpenESDFile()
 529 {
 530   //Open the ESD file
 531   Bool_t rv = kTRUE ;
 532   if (!fESDFile) {
 533     fESDFile = TFile::Open(fESDFileName) ;
 534     if (!fESDFile )
 535       return kFALSE ;
 536   }
 537   else if (fESDFile->IsOpen()) {
 538     fESDFile->Close() ;
 539     fESDFile = TFile::Open(fESDFileName) ;
 540   }
 541   if (!fESDFile->IsOpen())
 542     rv = kFALSE ;
 543   return rv ;
 544 }
 545
 546 //____________________________________________________________________________
 547 Int_t AliPHOSGetter::ReadRaw(Int_t event)
 548 {
 549   // reads the raw format data, converts it into digits format and store digits in Digits()
 550   // container.
 551
 552   AliRawReaderFile rawReader(event) ;
 553   AliPHOSRawStream in(&rawReader);
 554
 555   TClonesArray * digits = Digits() ;
 556   digits->Clear() ;
 557   Int_t idigit = 0 ;
 558
 559   while ( in.Next() ) { // PHOS entries loop
 560
 561     Int_t amp = in.GetSignal() ;
 562     Double_t time = in.GetTime() ;
 563     Int_t relId[4], id ;
 564
 565     relId[0] = in.GetModule() ;
 566     if ( relId[0] >= PHOS()->GetRawFormatLowGainOffset() ) {
 567       relId[0] -=  PHOS()->GetRawFormatLowGainOffset() ;
 568     }
 569     relId[1] = 0 ;
 570     relId[2] = in.GetRow() ;
 571     relId[3] = in.GetColumn() ;
 572     PHOSGeometry()->RelToAbsNumbering(relId, id) ;
 573
 574     if (amp > 0 && id >=0 ) {
 575       new((*digits)[idigit]) AliPHOSDigit( -1, id, amp, time) ;
 576       idigit++ ;
 577     }
 578
 579   } // PHOS entries loop
 580
 581   digits->Sort() ;
 582
 583   return digits->GetEntriesFast() ;
 584 }
 585 //____________________________________________________________________________
 586 Int_t AliPHOSGetter::ReadTreeD()
 587 {
 588   // Read the Digits
 589
 590   PhosLoader()->CleanDigits() ;
 591   PhosLoader()->LoadDigits("UPDATE") ;
 592   PhosLoader()->LoadDigitizer("UPDATE") ;
 593   return Digits()->GetEntries() ;
 594 }
 595
 596 //____________________________________________________________________________
 597 Int_t AliPHOSGetter::ReadTreeH()
 598 {
 599   // Read the Hits
 600   PhosLoader()->CleanHits() ;
 601   // gets TreeH from the root file (PHOS.Hit.root)
 602   //if ( !IsLoaded("H") ) {
 603     PhosLoader()->LoadHits("UPDATE") ;
 604   //  SetLoaded("H") ;
 605   //}
 606   return Hits()->GetEntries() ;
 607 }
 608
 609 //____________________________________________________________________________
 610 Int_t AliPHOSGetter::ReadTreeR()
 611 {
 612   // Read the RecPoints
 613
 614   PhosLoader()->CleanRecPoints() ;
 615   // gets TreeR from the root file (PHOS.RecPoints.root)
 616   //if ( !IsLoaded("R") ) {
 617     PhosLoader()->LoadRecPoints("UPDATE") ;
 618     PhosLoader()->LoadClusterizer("UPDATE") ;
 619     //  SetLoaded("R") ;
 620     //}
 621
 622   return EmcRecPoints()->GetEntries() ;
 623 }
 624
 625 //____________________________________________________________________________
 626 Int_t AliPHOSGetter::ReadTreeT()
 627 {
 628   // Read the TrackSegments
 629
 630   PhosLoader()->CleanTracks() ;
 631   // gets TreeT from the root file (PHOS.TrackSegments.root)
 632   //if ( !IsLoaded("T") ) {
 633     PhosLoader()->LoadTracks("UPDATE") ;
 634     PhosLoader()->LoadTrackSegmentMaker("UPDATE") ;
 635     //    SetLoaded("T") ;
 636     //}
 637
 638   return TrackSegments()->GetEntries() ;
 639 }
 640 //____________________________________________________________________________
 641 Int_t AliPHOSGetter::ReadTreeP()
 642 {
 643   // Read the RecParticles
 644
 645   PhosLoader()->CleanRecParticles() ;
 646
 647   // gets TreeT from the root file (PHOS.TrackSegments.root)
 648   //  if ( !IsLoaded("P") ) {
 649     PhosLoader()->LoadRecParticles("UPDATE") ;
 650     PhosLoader()->LoadPID("UPDATE") ;
 651     //  SetLoaded("P") ;
 652     //}
 653
 654   return RecParticles()->GetEntries() ;
 655 }
 656 //____________________________________________________________________________
 657 Int_t AliPHOSGetter::ReadTreeS()
 658 {
 659   // Read the SDigits
 660
 661   PhosLoader()->CleanSDigits() ;
 662   // gets TreeS from the root file (PHOS.SDigits.root)
 663   //if ( !IsLoaded("S") ) {
 664     PhosLoader()->LoadSDigits("READ") ;
 665     PhosLoader()->LoadSDigitizer("READ") ;
 666     //  SetLoaded("S") ;
 667     //}
 668
 669   return SDigits()->GetEntries() ;
 670 }
 671
 672 //____________________________________________________________________________
 673 Int_t AliPHOSGetter::ReadTreeE(Int_t event)
 674 {
 675   // Read the ESD
 676
 677   // gets esdTree from the root file (AliESDs.root)
 678   if (!fESDFile)
 679     if ( !OpenESDFile() )
 680       return -1 ;
 681
 682   fESDTree = static_cast<TTree*>(fESDFile->Get("esdTree")) ;
 683   fESD = new AliESD;
 684    if (!fESDTree) {
 685
 686      Error("ReadTreeE", "no ESD tree found");
 687      return -1;
 688    }
 689    fESDTree->SetBranchAddress("ESD", &fESD);
 690    fESDTree->GetEvent(event);
 691
 692    return event ;
 693 }
 694
 695 //____________________________________________________________________________
 696 TClonesArray * AliPHOSGetter::SDigits()
 697 {
 698   // asks the Loader to return the Digits container
 699
 700   TClonesArray * rv = 0 ;
 701
 702   rv = PhosLoader()->SDigits() ;
 703   if (!rv) {
 704     PhosLoader()->MakeSDigitsArray() ;
 705     rv = PhosLoader()->SDigits() ;
 706   }
 707   return rv ;
 708 }
 709
 710 //____________________________________________________________________________
 711 AliPHOSSDigitizer * AliPHOSGetter::SDigitizer()
 712 {
 713   // Returns pointer to the SDigitizer task
 714   AliPHOSSDigitizer * rv ;
 715   rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 716   if (!rv) {
 717     Event(0, "S") ;
 718     rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
 719   }
 720   return rv ;
 721 }
 722
 723 //____________________________________________________________________________
 724 TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
 725 {
 726   // Return first (index=1) or second (index=2) secondary particle of primary particle p
 727
 728   if(index <= 0)
 729     return 0 ;
 730   if(index > 2)
 731     return 0 ;
 732
 733   if(p) {
 734   Int_t daughterIndex = p->GetDaughter(index-1) ;
 735   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 736   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ;
 737   }
 738   else
 739     return 0 ;
 740 }
 741
 742 //____________________________________________________________________________
 743 void AliPHOSGetter::Track(Int_t itrack)
 744 {
 745   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
 746
 747  AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 748
 749   if( !TreeH() ) // load treeH the first time
 750     rl->LoadHits() ;
 751
 752   // first time create the container
 753   TClonesArray * hits = Hits() ;
 754   if ( hits )
 755     hits->Clear() ;
 756
 757   TBranch * phosbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("PHOS")) ;
 758   phosbranch->SetAddress(&hits) ;
 759   phosbranch->GetEntry(itrack) ;
 760 }
 761
 762 //____________________________________________________________________________
 763 TTree * AliPHOSGetter::TreeD() const
 764 {
 765   // Returns pointer to the Digits Tree
 766   TTree * rv = 0 ;
 767   rv = PhosLoader()->TreeD() ;
 768   if ( !rv ) {
 769     PhosLoader()->MakeTree("D");
 770     rv = PhosLoader()->TreeD() ;
 771   }
 772
 773   return rv ;
 774 }
 775
 776 //____________________________________________________________________________
 777 TTree * AliPHOSGetter::TreeH() const
 778 {
 779   // Returns pointer to the Hits Tree
 780   TTree * rv = 0 ;
 781   rv = PhosLoader()->TreeH() ;
 782   if ( !rv ) {
 783     PhosLoader()->MakeTree("H");
 784     rv = PhosLoader()->TreeH() ;
 785   }
 786
 787   return rv ;
 788 }
 789
 790 //____________________________________________________________________________
 791 TTree * AliPHOSGetter::TreeR() const
 792 {
 793   // Returns pointer to the RecPoints Tree
 794   TTree * rv = 0 ;
 795   rv = PhosLoader()->TreeR() ;
 796   if ( !rv ) {
 797     PhosLoader()->MakeTree("R");
 798     rv = PhosLoader()->TreeR() ;
 799   }
 800
 801   return rv ;
 802 }
 803
 804 //____________________________________________________________________________
 805 TTree * AliPHOSGetter::TreeT() const
 806 {
 807   // Returns pointer to the TrackSegments Tree
 808   TTree * rv = 0 ;
 809   rv = PhosLoader()->TreeT() ;
 810   if ( !rv ) {
 811     PhosLoader()->MakeTree("T");
 812     rv = PhosLoader()->TreeT() ;
 813   }
 814
 815   return rv ;
 816 }
 817 //____________________________________________________________________________
 818 TTree * AliPHOSGetter::TreeP() const
 819 {
 820   // Returns pointer to the RecParticles  Tree
 821   TTree * rv = 0 ;
 822   rv = PhosLoader()->TreeP() ;
 823   if ( !rv ) {
 824     PhosLoader()->MakeTree("P");
 825     rv = PhosLoader()->TreeP() ;
 826   }
 827
 828   return rv ;
 829 }
 830
 831 //____________________________________________________________________________
 832 TTree * AliPHOSGetter::TreeS() const
 833 {
 834  // Returns pointer to the SDigits Tree
 835   TTree * rv = 0 ;
 836   rv = PhosLoader()->TreeS() ;
 837   if ( !rv ) {
 838     PhosLoader()->MakeTree("S");
 839     rv = PhosLoader()->TreeS() ;
 840   }
 841
 842   return rv ;
 843 }
 844
 845 //____________________________________________________________________________
 846 Bool_t AliPHOSGetter::VersionExists(TString & opt) const
 847 {
 848   // checks if the version with the present name already exists in the same directory
 849
 850   Bool_t rv = kFALSE ;
 851
 852   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
 853   TString version( rl->GetEventFolder()->GetName() ) ;
 854
 855   opt.ToLower() ;
 856
 857   if ( opt == "sdigits") {
 858     // add the version name to the root file name
 859     TString fileName( PhosLoader()->GetSDigitsFileName() ) ;
 860     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 861       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 862     if ( !(gSystem->AccessPathName(fileName)) ) {
 863       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 864       rv = kTRUE ;
 865     }
 866     PhosLoader()->SetSDigitsFileName(fileName) ;
 867   }
 868
 869   if ( opt == "digits") {
 870     // add the version name to the root file name
 871     TString fileName( PhosLoader()->GetDigitsFileName() ) ;
 872     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
 873       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
 874     if ( !(gSystem->AccessPathName(fileName)) ) {
 875       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
 876       rv = kTRUE ;
 877     }
 878   }
 879
 880   return rv ;
 881
 882 }
 883
 884 //____________________________________________________________________________
 885 UShort_t AliPHOSGetter::EventPattern(void) const
 886 {
 887   // Return the pattern (trigger bit register) of the beam-test event
 888   if(fBTE)
 889     return fBTE->GetPattern() ;
 890   else
 891     return 0 ;
 892 }
 893 //____________________________________________________________________________
 894 Float_t AliPHOSGetter::BeamEnergy(void) const
 895 {
 896   // Return the beam energy of the beam-test event
 897   if(fBTE)
 898     return fBTE->GetBeamEnergy() ;
 899   else
 900     return 0 ;
 901 }