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