Changes needed to run simulation and reconstrruction in the same AliRoot session
[u/mrichter/AliRoot.git] / 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 }