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