Fixing Coding violations
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALGetter.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 AliEMCALAnalyser):
28 //  AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ;
29 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
30 //     AliEMCALRecParticle * 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 AliEMCALIndexToObject 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
47
48 // --- Standard library ---
49
50 // --- AliRoot header files ---
51
52 #include "AliEMCAL.h"
53 #include "AliEMCALGetter.h"
54 #include "AliEMCALLoader.h"
55 #include "AliHeader.h"  
56 #include "AliMC.h"
57 #include "AliRunLoader.h"
58 #include "AliStack.h"  
59
60 ClassImp(AliEMCALGetter)
61   
62 AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
63 AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
64 Int_t AliEMCALGetter::fgDebug = 0;
65
66 //  TFile * AliEMCALGetter::fgFile = 0 ; 
67
68 //____________________________________________________________________________ 
69 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption)
70 {
71   // ctor only called by Instance()
72
73   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ; 
74   if (!rl) {
75     rl = AliRunLoader::Open(headerFile, version, openingOption);
76     if (!rl) {
77       Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ; 
78       return ;
79     } 
80     if (rl->GetAliRun() == 0x0) {
81       rl->LoadgAlice();
82       gAlice = rl->GetAliRun(); // should be removed
83     }
84   }
85   fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
86   if ( !fgEmcalLoader ) 
87     Error("AliEMCALGetter", "Could not find EMCALLoader") ; 
88   else 
89     fgEmcalLoader->SetTitle(version);
90   
91   
92   // initialize data members
93   SetDebug(0) ; 
94   //fBTE = 0 ; 
95   fPrimaries = 0 ; 
96   fLoadingStatus = "" ; 
97 }
98
99 //____________________________________________________________________________ 
100 AliEMCALGetter::~AliEMCALGetter()
101 {
102   // dtor
103   delete fgEmcalLoader ;
104   fgEmcalLoader = 0 ;
105   //delete fBTE ; 
106   // fBTE = 0 ; 
107   fPrimaries->Delete() ; 
108   delete fPrimaries ; 
109   fgObjGetter = 0; 
110 }
111
112 //____________________________________________________________________________ 
113 void AliEMCALGetter::Reset()
114 {
115   // resets things in case the getter is called consecutively with different files
116   // the EMCAL Loader is already deleted by the Run Loader
117
118   if (fPrimaries) { 
119     fPrimaries->Delete() ; 
120     delete fPrimaries ;
121   } 
122   fgEmcalLoader = 0; 
123   fgObjGetter = 0; 
124 }
125
126 //____________________________________________________________________________ 
127 AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
128
129   // return pointer to Clusterizer Tree
130   AliEMCALClusterizer * rv ; 
131   rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
132   if (!rv) {
133     Event(0, "R") ; 
134     rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
135   }
136   return rv ; 
137 }
138
139
140 //____________________________________________________________________________ 
141 TClonesArray * AliEMCALGetter::Digits() const  
142 {
143   // asks the Loader to return the Digits container 
144
145   TClonesArray * rv = 0 ; 
146   rv = EmcalLoader()->Digits() ; 
147
148   if( !rv ) {
149     EmcalLoader()->MakeDigitsArray() ; 
150     rv = EmcalLoader()->Digits() ;
151   }
152   return rv ; 
153 }
154
155 //____________________________________________________________________________ 
156 AliEMCALDigitizer * AliEMCALGetter::Digitizer() 
157
158   // return pointer to Digitizer Tree
159   AliEMCALDigitizer * rv ; 
160   rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
161   if (!rv) {
162     Event(0, "D") ; 
163     rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
164   }
165   return rv ; 
166 }
167
168 //____________________________________________________________________________ 
169 TObjArray * AliEMCALGetter::ECARecPoints() const 
170 {
171   // asks the Loader to return the EMC RecPoints container 
172
173   TObjArray * rv = 0 ; 
174   
175   rv = EmcalLoader()->ECARecPoints() ; 
176   if (!rv) {
177     EmcalLoader()->MakeRecPointsArray() ;
178     rv = EmcalLoader()->ECARecPoints() ; 
179   }
180   return rv ; 
181 }
182
183 //____________________________________________________________________________ 
184 TClonesArray * AliEMCALGetter::TrackSegments() const 
185 {
186   // asks the Loader to return the TrackSegments container 
187
188   TClonesArray * rv = 0 ; 
189   
190   rv = EmcalLoader()->TrackSegments() ; 
191   if (!rv) {
192     EmcalLoader()->MakeTrackSegmentsArray() ;
193     rv = EmcalLoader()->TrackSegments() ; 
194   }
195   return rv ; 
196 }
197
198 //____________________________________________________________________________ 
199 AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker() 
200
201   // return pointer to TrackSegmentMaker Tree
202   AliEMCALTrackSegmentMaker * rv ; 
203   rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
204   if (!rv) {
205     Event(0, "T") ; 
206     rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
207   }
208   return rv ; 
209 }
210
211 //____________________________________________________________________________ 
212 TClonesArray * AliEMCALGetter::RecParticles() const  
213 {
214   // asks the Loader to return the TrackSegments container 
215
216   TClonesArray * rv = 0 ; 
217   
218   rv = EmcalLoader()->RecParticles() ; 
219   if (!rv) {
220     EmcalLoader()->MakeRecParticlesArray() ;
221     rv = EmcalLoader()->RecParticles() ; 
222   }
223   return rv ; 
224 }
225 //____________________________________________________________________________ 
226 void AliEMCALGetter::Event(Int_t event, const char* opt) 
227 {
228   // Reads the content of all Tree's S, D and R
229
230   if ( event >= MaxEvent() ) {
231     Error("Event", "%d not found in TreeE !", event) ; 
232     return ; 
233   }
234
235   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
236   // checks if we are dealing with test-beam data
237 //   TBranch * btb = rl->TreeE()->GetBranch("AliEMCALBeamTestEvent") ;
238 //   if(btb){
239 //     if(!fBTE)
240 //       fBTE = new AliEMCALBeamTestEvent() ;
241 //     btb->SetAddress(&fBTE) ;
242 //     btb->GetEntry(event) ;
243 //   }
244 //   else{
245 //     if(fBTE){
246 //       delete fBTE ;
247 //       fBTE = 0 ;
248 //     }
249 //   }
250
251   // Loads the type of object(s) requested
252   
253   rl->GetEvent(event) ;
254
255   if( strstr(opt,"X") || (strcmp(opt,"")==0) )
256     ReadPrimaries() ;
257
258   if(strstr(opt,"H") )
259     ReadTreeH();
260
261   if(strstr(opt,"S") )
262     ReadTreeS() ;
263
264   if( strstr(opt,"D") )
265     ReadTreeD() ;
266
267   if( strstr(opt,"R") )
268     ReadTreeR() ;
269
270   if( strstr(opt,"T") )
271     ReadTreeT() ;
272
273   if( strstr(opt,"P") )
274     ReadTreeP() ;
275  
276 }
277
278
279 //____________________________________________________________________________ 
280 Int_t AliEMCALGetter::EventNumber() const
281   {
282   // return the current event number
283   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
284   return static_cast<Int_t>(rl->GetEventNumber()) ;   
285 }
286
287 //____________________________________________________________________________ 
288   TClonesArray * AliEMCALGetter::Hits() const   
289 {
290   // asks the loader to return  the Hits container 
291   
292   TClonesArray * rv = 0 ; 
293   
294   rv = EmcalLoader()->Hits() ; 
295   if ( !rv ) {
296     EmcalLoader()->LoadHits("read"); 
297     rv = EmcalLoader()->Hits() ; 
298   }
299   return rv ; 
300 }
301
302 //____________________________________________________________________________ 
303 AliEMCALGetter * AliEMCALGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption) 
304 {
305   // Creates and returns the pointer of the unique instance
306   // Must be called only when the environment has changed
307   
308   if(!fgObjGetter){ // first time the getter is called 
309     fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
310   }
311   else { // the getter has been called previously
312     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
313     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
314       // check if the file is already open
315       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ; 
316       
317       if ( !galiceFile ) 
318         fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
319       
320       else {  // the file is already open check the version name
321         TString currentVersionName = rl->GetEventFolder()->GetName() ; 
322         TString newVersionName(version) ; 
323         if (currentVersionName == newVersionName) 
324           if(fgDebug)
325             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;  
326         else {
327           fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;      
328         }
329       }
330     }
331     else { 
332       AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
333       if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
334         delete rl ; 
335       fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;      
336     }
337   }
338   if (!fgObjGetter) 
339     ::Error("AliEMCALGetter::Instance", "Failed to create the EMCAL Getter object") ;
340   else 
341     if (fgDebug)
342       Print() ;
343   
344   return fgObjGetter ;
345 }
346
347 //____________________________________________________________________________ 
348 AliEMCALGetter *  AliEMCALGetter::Instance()
349 {
350   // Returns the pointer of the unique instance already defined
351   
352   if(!fgObjGetter && fgDebug)
353      ::Warning("AliEMCALGetter::Instance", "Getter not initialized") ;
354
355    return fgObjGetter ;
356            
357 }
358
359 //____________________________________________________________________________ 
360 Int_t AliEMCALGetter::MaxEvent() const 
361 {
362   // returns the number of events in the run (from TE)
363
364   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
365   return static_cast<Int_t>(rl->GetNumberOfEvents()) ; 
366 }
367
368 //____________________________________________________________________________ 
369 TParticle * AliEMCALGetter::Primary(Int_t index) const
370 {
371   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
372   return rl->Stack()->Particle(index) ; 
373
374
375 //____________________________________________________________________________ 
376 AliEMCAL * AliEMCALGetter:: EMCAL() const  
377 {
378   // returns the EMCAL object 
379   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(EmcalLoader()->GetModulesFolder()->FindObject("EMCAL")) ;  
380   if (!emcal) 
381     if (fgDebug)
382       Warning("EMCAL", "EMCAL module not found in module folders: %s", EmcalLoader()->GetModulesFolder()->GetName() ) ; 
383   return emcal ; 
384 }  
385
386
387
388 //____________________________________________________________________________ 
389 AliEMCALPID * AliEMCALGetter::PID() 
390
391   // return pointer to PID Tree
392   AliEMCALPID * rv ; 
393   rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
394   if (!rv) {
395     Event(0, "P") ; 
396     rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
397   }
398   return rv ; 
399 }
400
401 //____________________________________________________________________________ 
402 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() const 
403 {
404   // Returns EMCAL geometry
405
406   AliEMCALGeometry * rv = 0 ; 
407   if (EMCAL() )
408     rv =  EMCAL()->GetGeometry() ;
409   return rv ; 
410
411
412 //____________________________________________________________________________ 
413 TClonesArray * AliEMCALGetter::Primaries()  
414 {
415   // creates the Primaries container if needed
416   if ( !fPrimaries ) {
417     if (fgDebug) 
418       Info("Primaries", "Creating a new TClonesArray for primaries") ; 
419     fPrimaries = new TClonesArray("TParticle", 1000) ;
420   } 
421   return fPrimaries ; 
422 }
423
424 //____________________________________________________________________________ 
425 void  AliEMCALGetter::Print() 
426 {
427   // Print usefull information about the getter
428     
429   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
430   ::Info("Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ; 
431 }
432
433 //____________________________________________________________________________ 
434 void AliEMCALGetter::ReadPrimaries()  
435 {
436   // Read Primaries from Kinematics.root
437   
438   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
439   
440   // gets kine tree from the root file (Kinematics.root)
441   if ( ! rl->TreeK() )  // load treeK the first time
442     rl->LoadKinematics() ;
443   
444   fNPrimaries = (rl->GetHeader())->GetNtrack(); 
445   if (fgDebug) 
446     Info("ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ; 
447
448   // first time creates the container
449   if ( Primaries() ) 
450     fPrimaries->Clear() ; 
451   
452   Int_t index = 0 ; 
453   for (index = 0 ; index < fNPrimaries; index++) { 
454     new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
455   }
456 }
457
458 //____________________________________________________________________________ 
459 Int_t AliEMCALGetter::ReadTreeD()
460 {
461   // Read the Digits
462   
463   
464   // gets TreeD from the root file (EMCAL.SDigits.root)
465   if ( !IsLoaded("D") ) {
466     EmcalLoader()->LoadDigits("UPDATE") ;
467     EmcalLoader()->LoadDigitizer("UPDATE") ;
468     SetLoaded("D") ; 
469   } 
470   return Digits()->GetEntries() ; 
471 }
472
473 //____________________________________________________________________________ 
474 Int_t AliEMCALGetter::ReadTreeH()
475 {
476   // Read the Hits
477     
478   // gets TreeH from the root file (EMCAL.Hit.root)
479   if ( !IsLoaded("H") ) {
480     EmcalLoader()->LoadHits("READ") ;
481     SetLoaded("H") ; 
482   }  
483   return Hits()->GetEntries() ; 
484 }
485
486 //____________________________________________________________________________ 
487 Int_t AliEMCALGetter::ReadTreeR()
488 {
489   // Read the RecPoints
490   
491   
492   // gets TreeR from the root file (EMCAL.RecPoints.root)
493   if ( !IsLoaded("R") ) {
494     EmcalLoader()->LoadRecPoints("UPDATE") ;
495     EmcalLoader()->LoadClusterizer("UPDATE") ;
496     SetLoaded("R") ; 
497   }
498
499   return ECARecPoints()->GetEntries() ; 
500 }
501
502 //____________________________________________________________________________ 
503 Int_t AliEMCALGetter::ReadTreeT()
504 {
505   // Read the TrackSegments
506   
507   
508   // gets TreeT from the root file (EMCAL.TrackSegments.root)
509   if ( !IsLoaded("T") ) {
510     EmcalLoader()->LoadTracks("UPDATE") ;
511     EmcalLoader()->LoadTrackSegmentMaker("UPDATE") ;
512     SetLoaded("T") ; 
513   }
514
515   return TrackSegments()->GetEntries() ; 
516 }
517 //____________________________________________________________________________ 
518 Int_t AliEMCALGetter::ReadTreeP()
519 {
520   // Read the TrackSegments
521   
522   
523   // gets TreeT from the root file (EMCAL.TrackSegments.root)
524   if ( !IsLoaded("P") ) {
525     EmcalLoader()->LoadRecParticles("UPDATE") ;
526     EmcalLoader()->LoadPID("UPDATE") ;
527     SetLoaded("P") ; 
528   }
529
530   return RecParticles()->GetEntries() ; 
531 }
532 //____________________________________________________________________________ 
533 Int_t AliEMCALGetter::ReadTreeS()
534 {
535   // Read the SDigits
536   
537   
538   // gets TreeS from the root file (EMCAL.SDigits.root)
539    if ( !IsLoaded("S") ) {
540     EmcalLoader()->LoadSDigits("READ") ;
541     EmcalLoader()->LoadSDigitizer("READ") ;
542     SetLoaded("S") ; 
543   }
544
545   return SDigits()->GetEntries() ; 
546 }
547
548 //____________________________________________________________________________ 
549 TClonesArray * AliEMCALGetter::SDigits() const  
550 {
551   // asks the Loader to return the Digits container 
552
553   TClonesArray * rv = 0 ; 
554   
555   rv = EmcalLoader()->SDigits() ; 
556   if (!rv) {
557     EmcalLoader()->MakeSDigitsArray() ;
558     rv = EmcalLoader()->SDigits() ; 
559   }
560   return rv ; 
561 }
562
563 //____________________________________________________________________________ 
564 AliEMCALSDigitizer * AliEMCALGetter::SDigitizer() 
565
566   // Return pointer to SDigitizer task
567   AliEMCALSDigitizer * rv ; 
568   rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
569   if (!rv) {
570     Event(0, "S") ; 
571     rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
572   }
573   return rv ; 
574 }
575
576 //____________________________________________________________________________ 
577 TParticle * AliEMCALGetter::Secondary(const TParticle* p, Int_t index) const
578 {
579   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
580
581   if(index <= 0) 
582     return 0 ;
583   if(index > 2)
584     return 0 ;
585
586   if(p) {
587   Int_t daughterIndex = p->GetDaughter(index-1) ; 
588   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
589   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ; 
590   }
591   else
592     return 0 ;
593 }
594
595 //____________________________________________________________________________ 
596 void AliEMCALGetter::Track(Int_t itrack) 
597 {
598   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
599  
600  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
601
602   if( !TreeH() ) // load treeH the first time
603     rl->LoadHits() ;
604
605   // first time create the container
606   TClonesArray * hits = Hits() ; 
607   if ( hits ) 
608     hits->Clear() ; 
609
610   TBranch * emcalbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("EMCAL")) ; 
611   emcalbranch->SetAddress(&hits) ;
612   emcalbranch->GetEntry(itrack) ;
613 }
614
615 //____________________________________________________________________________ 
616 TTree * AliEMCALGetter::TreeD() const 
617 {
618   // return pointer to Digits Tree
619   TTree * rv = 0 ; 
620   rv = EmcalLoader()->TreeD() ; 
621   if ( !rv ) {
622     EmcalLoader()->MakeTree("D");
623     rv = EmcalLoader()->TreeD() ;
624   } 
625   
626   return rv ; 
627 }
628
629 //____________________________________________________________________________ 
630 TTree * AliEMCALGetter::TreeH() const 
631 {
632   // return pointer to Hits Tree
633   TTree * rv = 0 ; 
634   rv = EmcalLoader()->TreeH() ; 
635   if ( !rv ) {
636     EmcalLoader()->MakeTree("H");
637     rv = EmcalLoader()->TreeH() ;
638   } 
639   
640   return rv ; 
641 }
642
643 //____________________________________________________________________________ 
644 TTree * AliEMCALGetter::TreeR() const 
645 {
646   // return pointer to RecPoints Tree
647
648   TTree * rv = 0 ; 
649   rv = EmcalLoader()->TreeR() ; 
650   if ( !rv ) {
651     EmcalLoader()->MakeTree("R");
652     rv = EmcalLoader()->TreeR() ;
653   } 
654   
655   return rv ; 
656 }
657
658 //____________________________________________________________________________ 
659 TTree * AliEMCALGetter::TreeT() const 
660 {  
661   // return pointer to TrackSegments Tree
662   TTree * rv = 0 ; 
663   rv = EmcalLoader()->TreeT() ; 
664   if ( !rv ) {
665     EmcalLoader()->MakeTree("T");
666     rv = EmcalLoader()->TreeT() ;
667   } 
668   
669   return rv ; 
670 }
671 //____________________________________________________________________________ 
672 TTree * AliEMCALGetter::TreeP() const 
673 {
674   // return pointer to RecParticles Tree
675   TTree * rv = 0 ; 
676   rv = EmcalLoader()->TreeP() ; 
677   if ( !rv ) {
678     EmcalLoader()->MakeTree("P");
679     rv = EmcalLoader()->TreeP() ;
680   } 
681   
682   return rv ; 
683 }
684
685 //____________________________________________________________________________ 
686 TTree * AliEMCALGetter::TreeS() const 
687 {
688   // return pointer to SDigits Tree
689   TTree * rv = 0 ; 
690   rv = EmcalLoader()->TreeS() ; 
691   if ( !rv ) {
692     EmcalLoader()->MakeTree("S");
693     rv = EmcalLoader()->TreeS() ;
694   } 
695   
696   return rv ; 
697 }
698
699 //____________________________________________________________________________ 
700 Bool_t AliEMCALGetter::VersionExists(TString & opt) const
701 {
702   // checks if the version with the present name already exists in the same directory
703
704   Bool_t rv = kFALSE ;
705  
706   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
707   TString version( rl->GetEventFolder()->GetName() ) ; 
708
709   opt.ToLower() ; 
710   
711   if ( opt == "sdigits") {
712     // add the version name to the root file name
713     TString fileName( EmcalLoader()->GetSDigitsFileName() ) ; 
714     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
715       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
716     if ( !(gSystem->AccessPathName(fileName)) ) { 
717       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
718       rv = kTRUE ; 
719     }
720     EmcalLoader()->SetSDigitsFileName(fileName) ;
721   }
722
723   if ( opt == "digits") {
724     // add the version name to the root file name
725     TString fileName( EmcalLoader()->GetDigitsFileName() ) ; 
726     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
727       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
728     if ( !(gSystem->AccessPathName(fileName)) ) {
729       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;  
730       rv = kTRUE ; 
731     }
732   }
733
734   return rv ;
735
736 }
737
738 //____________________________________________________________________________ 
739 UShort_t AliEMCALGetter::EventPattern(void) const
740 {
741   // Return the pattern (trigger bit register) of the beam-test event
742 //   if(fBTE)
743 //     return fBTE->GetPattern() ;
744 //   else
745     return 0 ;
746 }
747 //____________________________________________________________________________ 
748 Float_t AliEMCALGetter::BeamEnergy(void) const
749 {
750   // Return the beam energy of the beam-test event
751 //   if(fBTE)
752 //     return fBTE->GetBeamEnergy() ;
753 //   else
754     return 0 ;
755 }