7613c400c68a1f04570509e7b56f10a2d9d60c1f
[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 "TTree.h"
46 #include "TROOT.h"
47 // #include "TObjString.h"
48 // #include "TFolder.h"
49 // #include "TParticle.h"
50
51 // --- Standard library ---
52
53 // --- AliRoot header files ---
54 // #include "AliRun.h"
55 // #include "AliConfig.h"
56 #include "AliEMCALGetter.h"
57 #include "AliEMCAL.h"
58 #include "AliRunLoader.h"
59 #include "AliStack.h"  
60 #include "AliEMCALLoader.h"
61 #include "AliMC.h"
62
63 ClassImp(AliEMCALGetter)
64   
65 AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
66 AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
67 Int_t AliEMCALGetter::fgDebug = 0;
68
69 //  TFile * AliEMCALGetter::fgFile = 0 ; 
70
71 //____________________________________________________________________________ 
72 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption)
73 {
74   // ctor only called by Instance()
75
76   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ; 
77   if (!rl) {
78     rl = AliRunLoader::Open(headerFile, version, openingOption);
79     if (!rl) {
80       Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ; 
81       return ;
82     } 
83     if (rl->GetAliRun() == 0x0) {
84       rl->LoadgAlice();
85       gAlice = rl->GetAliRun(); // should be removed
86     }
87   }
88   fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
89   if ( !fgEmcalLoader ) 
90     Error("AliEMCALGetter", "Could not find EMCALLoader") ; 
91   else 
92     fgEmcalLoader->SetTitle(version);
93   
94   
95   // initialize data members
96   SetDebug(0) ; 
97   //fBTE = 0 ; 
98   fPrimaries = 0 ; 
99   fLoadingStatus = "" ; 
100 }
101
102 //____________________________________________________________________________ 
103 AliEMCALGetter::~AliEMCALGetter()
104 {
105   // dtor
106   delete fgEmcalLoader ;
107   fgEmcalLoader = 0 ;
108   //delete fBTE ; 
109   // fBTE = 0 ; 
110   fPrimaries->Delete() ; 
111   delete fPrimaries ; 
112 }
113
114 //____________________________________________________________________________ 
115 AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
116
117   AliEMCALClusterizer * rv ; 
118   rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
119   if (!rv) {
120     Event(0, "R") ; 
121     rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
122   }
123   return rv ; 
124 }
125
126
127 //____________________________________________________________________________ 
128 TClonesArray * AliEMCALGetter::Digits() 
129 {
130   // asks the Loader to return the Digits container 
131
132   TClonesArray * rv = 0 ; 
133   rv = EmcalLoader()->Digits() ; 
134
135   if( !rv ) {
136     EmcalLoader()->MakeDigitsArray() ; 
137     rv = EmcalLoader()->Digits() ;
138   }
139   return rv ; 
140 }
141
142 //____________________________________________________________________________ 
143 AliEMCALDigitizer * AliEMCALGetter::Digitizer() 
144
145   AliEMCALDigitizer * rv ; 
146   rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
147   if (!rv) {
148     Event(0, "D") ; 
149     rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
150   }
151   return rv ; 
152 }
153
154
155 //____________________________________________________________________________ 
156 TObjArray * AliEMCALGetter::PRERecPoints() 
157 {
158   // asks the Loader to return the EMC RecPoints container 
159
160   TObjArray * rv = 0 ; 
161   
162   rv = EmcalLoader()->PRERecPoints() ; 
163   if (!rv) {
164     EmcalLoader()->MakeRecPointsArray() ;
165     rv = EmcalLoader()->PRERecPoints() ; 
166   }
167   return rv ; 
168 }
169
170 //____________________________________________________________________________ 
171 TObjArray * AliEMCALGetter::ECARecPoints() 
172 {
173   // asks the Loader to return the EMC RecPoints container 
174
175   TObjArray * rv = 0 ; 
176   
177   rv = EmcalLoader()->ECARecPoints() ; 
178   if (!rv) {
179     EmcalLoader()->MakeRecPointsArray() ;
180     rv = EmcalLoader()->ECARecPoints() ; 
181   }
182   return rv ; 
183 }
184
185 //____________________________________________________________________________ 
186 TObjArray * AliEMCALGetter::HCARecPoints() 
187 {
188   // asks the Loader to return the EMC RecPoints container 
189
190   TObjArray * rv = 0 ; 
191   
192   rv = EmcalLoader()->HCARecPoints() ; 
193   if (!rv) {
194     EmcalLoader()->MakeRecPointsArray() ;
195     rv = EmcalLoader()->HCARecPoints() ; 
196   }
197   return rv ; 
198 }
199
200 //____________________________________________________________________________ 
201 TClonesArray * AliEMCALGetter::TrackSegments() 
202 {
203   // asks the Loader to return the TrackSegments container 
204
205   TClonesArray * rv = 0 ; 
206   
207   rv = EmcalLoader()->TrackSegments() ; 
208   if (!rv) {
209     EmcalLoader()->MakeTrackSegmentsArray() ;
210     rv = EmcalLoader()->TrackSegments() ; 
211   }
212   return rv ; 
213 }
214
215 //____________________________________________________________________________ 
216 AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker() 
217
218   AliEMCALTrackSegmentMaker * rv ; 
219   rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
220   if (!rv) {
221     Event(0, "T") ; 
222     rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
223   }
224   return rv ; 
225 }
226
227 //____________________________________________________________________________ 
228 TClonesArray * AliEMCALGetter::RecParticles() 
229 {
230   // asks the Loader to return the TrackSegments container 
231
232   TClonesArray * rv = 0 ; 
233   
234   rv = EmcalLoader()->RecParticles() ; 
235   if (!rv) {
236     EmcalLoader()->MakeRecParticlesArray() ;
237     rv = EmcalLoader()->RecParticles() ; 
238   }
239   return rv ; 
240 }
241 //____________________________________________________________________________ 
242 void AliEMCALGetter::Event(const Int_t event, const char* opt) 
243 {
244   // Reads the content of all Tree's S, D and R
245
246   if ( event >= MaxEvent() ) {
247     Error("Event", "%d not found in TreeE !", event) ; 
248     return ; 
249   }
250
251   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
252
253   // checks if we are dealing with test-beam data
254 //   TBranch * btb = rl->TreeE()->GetBranch("AliEMCALBeamTestEvent") ;
255 //   if(btb){
256 //     if(!fBTE)
257 //       fBTE = new AliEMCALBeamTestEvent() ;
258 //     btb->SetAddress(&fBTE) ;
259 //     btb->GetEntry(event) ;
260 //   }
261 //   else{
262 //     if(fBTE){
263 //       delete fBTE ;
264 //       fBTE = 0 ;
265 //     }
266 //   }
267
268   // Loads the type of object(s) requested
269   
270   rl->GetEvent(event) ;
271
272   if( strstr(opt,"X") || (strcmp(opt,"")==0) )
273     ReadPrimaries() ;
274
275   if(strstr(opt,"H") )
276     ReadTreeH();
277
278   if(strstr(opt,"S") )
279     ReadTreeS() ;
280
281   if( strstr(opt,"D") )
282     ReadTreeD() ;
283
284   if( strstr(opt,"R") )
285     ReadTreeR() ;
286
287   if( strstr(opt,"T") )
288     ReadTreeT() ;
289
290   if( strstr(opt,"P") )
291     ReadTreeP() ;
292
293 //   if( strstr(opt,"Q") )
294 //     ReadTreeQA() ;
295  
296 }
297
298
299 //____________________________________________________________________________ 
300 Int_t AliEMCALGetter::EventNumber() const
301   {
302   // return the current event number
303   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
304   return static_cast<Int_t>(rl->GetEventNumber()) ;   
305 }
306
307 //____________________________________________________________________________ 
308   TClonesArray * AliEMCALGetter::Hits()  
309 {
310   // asks the loader to return  the Hits container 
311   
312   TClonesArray * rv = 0 ; 
313   
314   rv = EmcalLoader()->Hits() ; 
315   if ( !rv ) {
316     EmcalLoader()->LoadHits("read"); 
317     rv = EmcalLoader()->Hits() ; 
318   }
319   return rv ; 
320 }
321
322 //____________________________________________________________________________ 
323 AliEMCALGetter * AliEMCALGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption) 
324 {
325   // Creates and returns the pointer of the unique instance
326   // Must be called only when the environment has changed
327   
328   //::Info("Instance","alirunFileName=%s version=%s openingOption=%s",alirunFileName,version,openingOption);
329   
330   if(!fgObjGetter){ // first time the getter is called 
331     fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
332   }
333   else { // the getter has been called previously
334     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
335     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
336       // check if the file is already open
337       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ; 
338       
339       if ( !galiceFile ) 
340         fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
341       
342       else {  // the file is already open check the version name
343         TString currentVersionName = rl->GetEventFolder()->GetName() ; 
344         TString newVersionName(version) ; 
345         if (currentVersionName == newVersionName) 
346           if(fgDebug)
347             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;  
348         else {
349           fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;      
350         }
351       }
352     }
353     else 
354       fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;      
355   }
356   if (!fgObjGetter) 
357     ::Error("Instance", "Failed to create the EMCAL Getter object") ;
358   else 
359     if (fgDebug)
360       Print() ;
361   
362   return fgObjGetter ;
363 }
364
365 //____________________________________________________________________________ 
366 AliEMCALGetter *  AliEMCALGetter::Instance()
367 {
368   // Returns the pointer of the unique instance already defined
369   
370   if(!fgObjGetter)
371      ::Error("Instance", "Getter not initialized") ;
372
373    return fgObjGetter ;
374            
375 }
376
377 //____________________________________________________________________________ 
378 Int_t AliEMCALGetter::MaxEvent() const 
379 {
380   // returns the number of events in the run (from TE)
381
382   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
383   return static_cast<Int_t>(rl->GetNumberOfEvents()) ; 
384 }
385
386 //____________________________________________________________________________ 
387 TParticle * AliEMCALGetter::Primary(Int_t index) const
388 {
389   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
390   return rl->Stack()->Particle(index) ; 
391
392
393 //____________________________________________________________________________ 
394 AliEMCAL * AliEMCALGetter:: EMCAL() const  
395 {
396   // returns the EMCAL object 
397   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(EmcalLoader()->GetModulesFolder()->FindObject("EMCAL")) ;  
398   if (!emcal) 
399     if (fgDebug)
400       Warning("EMCAL", "EMCAL module not found in module folders: %s", EmcalLoader()->GetModulesFolder()->GetName() ) ; 
401   return emcal ; 
402 }  
403
404
405
406 //____________________________________________________________________________ 
407 AliEMCALPID * AliEMCALGetter::PID() 
408
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() 
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   AliEMCALSDigitizer * rv ; 
586   rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
587   if (!rv) {
588     Event(0, "S") ; 
589     rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
590   }
591   return rv ; 
592 }
593
594 //____________________________________________________________________________ 
595 TParticle * AliEMCALGetter::Secondary(const TParticle* p, const Int_t index) const
596 {
597   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
598
599   if(index <= 0) 
600     return 0 ;
601   if(index > 2)
602     return 0 ;
603
604   if(p) {
605   Int_t daughterIndex = p->GetDaughter(index-1) ; 
606   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
607   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ; 
608   }
609   else
610     return 0 ;
611 }
612
613 //____________________________________________________________________________ 
614 void AliEMCALGetter::Track(const Int_t itrack) 
615 {
616   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
617  
618  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
619
620   if( !TreeH() ) // load treeH the first time
621     rl->LoadHits() ;
622
623   // first time create the container
624   TClonesArray * hits = Hits() ; 
625   if ( hits ) 
626     hits->Clear() ; 
627
628   TBranch * emcalbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("EMCAL")) ; 
629   emcalbranch->SetAddress(&hits) ;
630   emcalbranch->GetEntry(itrack) ;
631 }
632
633 //____________________________________________________________________________ 
634 TTree * AliEMCALGetter::TreeD() const 
635 {
636   TTree * rv = 0 ; 
637   rv = EmcalLoader()->TreeD() ; 
638   if ( !rv ) {
639     EmcalLoader()->MakeTree("D");
640     rv = EmcalLoader()->TreeD() ;
641   } 
642   
643   return rv ; 
644 }
645
646 //____________________________________________________________________________ 
647 TTree * AliEMCALGetter::TreeH() const 
648 {
649   TTree * rv = 0 ; 
650   rv = EmcalLoader()->TreeH() ; 
651   if ( !rv ) {
652     EmcalLoader()->MakeTree("H");
653     rv = EmcalLoader()->TreeH() ;
654   } 
655   
656   return rv ; 
657 }
658
659 //____________________________________________________________________________ 
660 TTree * AliEMCALGetter::TreeR() const 
661 {
662   TTree * rv = 0 ; 
663   rv = EmcalLoader()->TreeR() ; 
664   if ( !rv ) {
665     EmcalLoader()->MakeTree("R");
666     rv = EmcalLoader()->TreeR() ;
667   } 
668   
669   return rv ; 
670 }
671
672 //____________________________________________________________________________ 
673 TTree * AliEMCALGetter::TreeT() const 
674 {
675   TTree * rv = 0 ; 
676   rv = EmcalLoader()->TreeT() ; 
677   if ( !rv ) {
678     EmcalLoader()->MakeTree("T");
679     rv = EmcalLoader()->TreeT() ;
680   } 
681   
682   return rv ; 
683 }
684 //____________________________________________________________________________ 
685 TTree * AliEMCALGetter::TreeP() const 
686 {
687   TTree * rv = 0 ; 
688   rv = EmcalLoader()->TreeP() ; 
689   if ( !rv ) {
690     EmcalLoader()->MakeTree("P");
691     rv = EmcalLoader()->TreeP() ;
692   } 
693   
694   return rv ; 
695 }
696
697 //____________________________________________________________________________ 
698 TTree * AliEMCALGetter::TreeS() const 
699 {
700   TTree * rv = 0 ; 
701   rv = EmcalLoader()->TreeS() ; 
702   if ( !rv ) {
703     EmcalLoader()->MakeTree("S");
704     rv = EmcalLoader()->TreeS() ;
705   } 
706   
707   return rv ; 
708 }
709
710 //____________________________________________________________________________ 
711 Bool_t AliEMCALGetter::VersionExists(TString & opt) const
712 {
713   // checks if the version with the present name already exists in the same directory
714
715   Bool_t rv = kFALSE ;
716  
717   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
718   TString version( rl->GetEventFolder()->GetName() ) ; 
719
720   opt.ToLower() ; 
721   
722   if ( opt == "sdigits") {
723     // add the version name to the root file name
724     TString fileName( EmcalLoader()->GetSDigitsFileName() ) ; 
725     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
726       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
727     if ( !(gSystem->AccessPathName(fileName)) ) { 
728       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
729       rv = kTRUE ; 
730     }
731     EmcalLoader()->SetSDigitsFileName(fileName) ;
732   }
733
734   if ( opt == "digits") {
735     // add the version name to the root file name
736     TString fileName( EmcalLoader()->GetDigitsFileName() ) ; 
737     if (version != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
738       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
739     if ( !(gSystem->AccessPathName(fileName)) ) {
740       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;  
741       rv = kTRUE ; 
742     }
743     EmcalLoader()->SetDigitsFileName(fileName) ;
744   }
745
746   return rv ;
747
748 }
749
750 //____________________________________________________________________________ 
751 UShort_t AliEMCALGetter::EventPattern(void) const
752 {
753   // Return the pattern (trigger bit register) of the beam-test event
754 //   if(fBTE)
755 //     return fBTE->GetPattern() ;
756 //   else
757     return 0 ;
758 }
759 //____________________________________________________________________________ 
760 Float_t AliEMCALGetter::BeamEnergy(void) const
761 {
762   // Return the beam energy of the beam-test event
763 //   if(fBTE)
764 //     return fBTE->GetBeamEnergy() ;
765 //   else
766     return 0 ;
767 }