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