Changes needed to run simulation and reconstrruction in the same AliRoot session
[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 #include <TF1.h>
47 #include <TGraph.h>
48 //#include <TCanvas.h>
49 //#include <TFrame.h>
50
51 // --- Standard library ---
52
53 // --- AliRoot header files ---
54
55 #include "AliEMCAL.h"
56 #include "AliEMCALGetter.h"
57 #include "AliEMCALLoader.h"
58 #include "AliHeader.h"  
59 #include "AliMC.h"
60 #include "AliRunLoader.h"
61 #include "AliStack.h"  
62 #include "AliEMCALRawStream.h"
63 #include "AliRawReaderFile.h"
64
65 ClassImp(AliEMCALGetter)
66   
67 AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
68 AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
69 Int_t AliEMCALGetter::fgDebug = 0;
70
71 //  TFile * AliEMCALGetter::fgFile = 0 ; 
72
73 //____________________________________________________________________________ 
74 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption) {
75   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ; 
76   if (!rl) {
77     rl = AliRunLoader::Open(headerFile, version, openingOption);
78     if (!rl) {
79       Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ; 
80       return ;
81     } 
82     if (rl->GetAliRun() == 0x0) {
83       rl->LoadgAlice();
84       gAlice = rl->GetAliRun(); // should be removed
85     }
86   } 
87   fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
88   if ( !fgEmcalLoader ) 
89     Error("AliEMCALGetter", "Could not find EMCALLoader") ; 
90   else 
91     fgEmcalLoader->SetTitle(version);
92
93    // initialize data members
94   SetDebug(0) ; 
95   fLoadingStatus = "" ; 
96
97 }
98
99 //____________________________________________________________________________ 
100 AliEMCALGetter::~AliEMCALGetter()
101 {
102   if (fgEmcalLoader) {
103     delete fgEmcalLoader;
104     fgEmcalLoader = 0 ;
105   }
106   fgObjGetter = 0;
107 }
108
109
110 //____________________________________________________________________________ 
111 void AliEMCALGetter::Reset()
112 {
113   // resets things in case the getter is called consecutively with different files
114   // the EMCAL Loader is already deleted by the Run Loader
115   fgEmcalLoader = 0;
116   fgObjGetter = 0;
117
118 }
119
120 //____________________________________________________________________________ 
121 AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
122
123   // return pointer to Clusterizer Tree
124   AliEMCALClusterizer * rv ; 
125   rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
126   if (!rv) {
127     Event(0, "R") ; 
128     rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
129   }
130   return rv ; 
131 }
132
133
134 //____________________________________________________________________________ 
135 TClonesArray * AliEMCALGetter::Digits() const  
136 {
137   // asks the Loader to return the Digits container 
138
139   TClonesArray * rv = 0 ; 
140   rv = EmcalLoader()->Digits() ; 
141
142   if( !rv ) {
143     EmcalLoader()->MakeDigitsArray() ; 
144     rv = EmcalLoader()->Digits() ;
145   }
146   return rv ; 
147 }
148
149 //____________________________________________________________________________ 
150 AliEMCALDigitizer * AliEMCALGetter::Digitizer() 
151
152   // return pointer to Digitizer Tree
153   AliEMCALDigitizer * rv ; 
154   rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
155   if (!rv) {
156     Event(0, "D") ; 
157     rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
158   }
159   return rv ; 
160 }
161
162 //____________________________________________________________________________ 
163 TObjArray * AliEMCALGetter::ECARecPoints() const 
164 {
165   // asks the Loader to return the EMC RecPoints container 
166
167   TObjArray * rv = 0 ; 
168   
169   rv = EmcalLoader()->ECARecPoints() ; 
170   if (!rv) {
171     EmcalLoader()->MakeRecPointsArray() ;
172     rv = EmcalLoader()->ECARecPoints() ; 
173   }
174   return rv ; 
175 }
176
177 //____________________________________________________________________________ 
178 TClonesArray * AliEMCALGetter::TrackSegments() const 
179 {
180   // asks the Loader to return the TrackSegments container 
181
182   TClonesArray * rv = 0 ; 
183   
184   rv = EmcalLoader()->TrackSegments() ; 
185   if (!rv) {
186     EmcalLoader()->MakeTrackSegmentsArray() ;
187     rv = EmcalLoader()->TrackSegments() ; 
188   }
189   return rv ; 
190 }
191
192 //____________________________________________________________________________ 
193 AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker() 
194
195   // return pointer to TrackSegmentMaker Tree
196   AliEMCALTrackSegmentMaker * rv ; 
197   rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
198   if (!rv) {
199     Event(0, "T") ; 
200     rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
201   }
202   return rv ; 
203 }
204
205 //____________________________________________________________________________ 
206 TClonesArray * AliEMCALGetter::RecParticles() const  
207 {
208   // asks the Loader to return the TrackSegments container 
209
210   TClonesArray * rv = 0 ; 
211   
212   rv = EmcalLoader()->RecParticles() ; 
213   if (!rv) {
214     EmcalLoader()->MakeRecParticlesArray() ;
215     rv = EmcalLoader()->RecParticles() ; 
216   }
217   return rv ; 
218 }
219 //____________________________________________________________________________ 
220 void AliEMCALGetter::Event(Int_t event, const char* opt) 
221 {
222   // Reads the content of all Tree's S, D and R
223
224 //   if ( event >= MaxEvent() ) {
225 //     Error("Event", "%d not found in TreeE !", event) ; 
226 //     return ; 
227 //   }
228
229   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
230   // checks if we are dealing with test-beam data
231 //   TBranch * btb = rl->TreeE()->GetBranch("AliEMCALBeamTestEvent") ;
232 //   if(btb){
233 //     if(!fBTE)
234 //       fBTE = new AliEMCALBeamTestEvent() ;
235 //     btb->SetAddress(&fBTE) ;
236 //     btb->GetEntry(event) ;
237 //   }
238 //   else{
239 //     if(fBTE){
240 //       delete fBTE ;
241 //       fBTE = 0 ;
242 //     }
243 //   }
244
245   // Loads the type of object(s) requested
246   
247   rl->GetEvent(event) ;
248
249   if( strstr(opt,"X") || (strcmp(opt,"")==0) )
250     ReadPrimaries() ;
251
252   if(strstr(opt,"H") )
253     ReadTreeH();
254
255   if(strstr(opt,"S") )
256     ReadTreeS() ;
257
258   if( strstr(opt,"D") )
259     ReadTreeD() ;
260
261   if( strstr(opt,"R") )
262     ReadTreeR() ;
263
264   if( strstr(opt,"T") )
265     ReadTreeT() ;
266
267   if( strstr(opt,"P") )
268     ReadTreeP() ;
269
270   if( strstr(opt,"W") )
271     ReadRaw(event) ;
272   
273 }
274
275
276 //____________________________________________________________________________ 
277 Int_t AliEMCALGetter::EventNumber() const
278   {
279   // return the current event number
280   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
281   return static_cast<Int_t>(rl->GetEventNumber()) ;   
282 }
283
284 //____________________________________________________________________________ 
285   TClonesArray * AliEMCALGetter::Hits() const   
286 {
287   // asks the loader to return  the Hits container 
288   
289   TClonesArray * rv = 0 ; 
290   
291   rv = EmcalLoader()->Hits() ; 
292   if ( !rv ) {
293     EmcalLoader()->LoadHits("read"); 
294     rv = EmcalLoader()->Hits() ; 
295   }
296   return rv ; 
297 }
298
299 //____________________________________________________________________________ 
300 AliEMCALGetter * AliEMCALGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption) 
301 {
302   // Creates and returns the pointer of the unique instance
303   // Must be called only when the environment has changed
304
305   if(!fgObjGetter){ // first time the getter is called 
306     fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;
307   }
308   else { // the getter has been called previously
309     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
310     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
311       // check if the file is already open
312       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ; 
313       
314       if ( !galiceFile ) 
315         fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption);
316       
317       else {  // the file is already open check the version name
318         TString currentVersionName = rl->GetEventFolder()->GetName() ; 
319         TString newVersionName(version) ; 
320         if (currentVersionName == newVersionName) 
321           if(fgDebug)
322             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;  
323         else {    
324           fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ; 
325         }
326       }
327     }
328     else { 
329       AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
330       if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
331         delete rl ; 
332       fgObjGetter = new AliEMCALGetter(alirunFileName, version, openingOption) ;      
333     }
334   }
335   if (!fgObjGetter) 
336     ::Error("AliEMCALGetter::Instance", "Failed to create the EMCAL Getter object") ;
337   else 
338     if (fgDebug)
339       Print() ;
340
341   return fgObjGetter ;
342 }
343
344 //____________________________________________________________________________ 
345 AliEMCALGetter *  AliEMCALGetter::Instance()
346 {
347   // Returns the pointer of the unique instance already defined
348   
349   if(!fgObjGetter && fgDebug)
350      ::Warning("AliEMCALGetter::Instance", "Getter not initialized") ;
351
352    return fgObjGetter ;
353            
354 }
355
356 //____________________________________________________________________________ 
357 Int_t AliEMCALGetter::MaxEvent() const 
358 {
359   // returns the number of events in the run (from TE)
360
361   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
362   return static_cast<Int_t>(rl->GetNumberOfEvents()) ; 
363 }
364
365 //____________________________________________________________________________ 
366 TParticle * AliEMCALGetter::Primary(Int_t index) const
367 {
368   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
369   return rl->Stack()->Particle(index) ; 
370
371
372 //____________________________________________________________________________ 
373 Int_t AliEMCALGetter::NPrimaries() const
374 {
375   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
376   return (rl->GetHeader())->GetNtrack(); 
377
378
379 //____________________________________________________________________________ 
380 AliEMCAL * AliEMCALGetter:: EMCAL() const  
381 {
382   // returns the EMCAL object 
383   AliEMCALLoader *    loader = 0;
384   static AliEMCALLoader * oldloader = 0;
385   static AliEMCAL * emcal = 0;
386
387   loader = EmcalLoader();
388
389   if (loader != oldloader ) {
390     emcal = dynamic_cast<AliEMCAL*>(loader->GetModulesFolder()->FindObject("EMCAL")) ;  
391     oldloader = loader;
392   }
393   if (!emcal) 
394     if (fgDebug)
395       Warning("EMCAL", "EMCAL module not found in module folders: %s", EmcalLoader()->GetModulesFolder()->GetName() ) ; 
396   return emcal ; 
397 }  
398
399
400
401 //____________________________________________________________________________ 
402 AliEMCALPID * AliEMCALGetter::PID() 
403
404   // return pointer to PID Tree
405   AliEMCALPID * rv ; 
406   rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
407   if (!rv) {
408     Event(0, "P") ; 
409     rv =  dynamic_cast<AliEMCALPID *>(EmcalLoader()->PIDTask()) ;
410   }
411   return rv ; 
412 }
413
414 //____________________________________________________________________________ 
415 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() const 
416 {
417   // Returns EMCAL geometry
418
419   AliEMCALGeometry * rv = 0 ; 
420   if (EMCAL() )
421     rv =  EMCAL()->GetGeometry() ;
422   return rv ; 
423
424
425 //____________________________________________________________________________ 
426 void  AliEMCALGetter::Print() 
427 {
428   // Print usefull information about the getter
429     
430   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgEmcalLoader->GetTitle());
431   ::Info("Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ; 
432 }
433
434 //____________________________________________________________________________ 
435 void AliEMCALGetter::ReadPrimaries()  
436 {
437   // Read Primaries from Kinematics.root
438   
439   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
440   
441   // gets kine tree from the root file (Kinematics.root)
442   if ( ! rl->TreeK() )  // load treeK the first time
443     rl->LoadKinematics() ;
444   
445   if (fgDebug) 
446     Info("ReadTreeK", "Found %d particles in event # %d", NPrimaries(), EventNumber() ) ; 
447 }
448
449 //____________________________________________________________________________ 
450 void AliEMCALGetter::FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Int_t & amp, Double_t & time)
451 {
452   // Fits the raw signal time distribution 
453
454   const Int_t kNoiseThreshold = 0 ;
455   Double_t timezero1 = 0., timezero2 = 0., timemax = 0. ;
456   Double_t signal = 0., signalmax = 0. ;       
457   Double_t energy = time = 0. ; 
458
459   if (lowGainFlag) {
460     timezero1 = timezero2 = signalmax = timemax = 0. ;
461     signalF->FixParameter(0, EMCAL()->GetRawFormatLowCharge()) ; 
462     signalF->FixParameter(1, EMCAL()->GetRawFormatLowGain()) ; 
463     Int_t index ; 
464     for (index = 0; index < EMCAL()->GetRawFormatTimeBins(); index++) {
465       gLowGain->GetPoint(index, time, signal) ; 
466       if (signal > kNoiseThreshold && timezero1 == 0.) 
467         timezero1 = time ;
468       if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
469         timezero2 = time ; 
470       if (signal > signalmax) {
471         signalmax = signal ; 
472         timemax   = time ; 
473       }
474     }
475     signalmax /= EMCAL()->RawResponseFunctionMax(EMCAL()->GetRawFormatLowCharge(), 
476                                                 EMCAL()->GetRawFormatLowGain()) ;
477     if ( timezero1 + EMCAL()->GetRawFormatTimePeak() < EMCAL()->GetRawFormatTimeMax() * 0.4 ) { // else its noise 
478       signalF->SetParameter(2, signalmax) ; 
479       signalF->SetParameter(3, timezero1) ;         
480       gLowGain->Fit(signalF, "QRON", "", 0., timezero2); //, "QRON") ; 
481       energy = signalF->GetParameter(2) ; 
482       time   = signalF->GetMaximumX() - EMCAL()->GetRawFormatTimePeak() - EMCAL()->GetRawFormatTimeTrigger() ;
483     }
484   } else {
485     timezero1 = timezero2 = signalmax = timemax = 0. ;
486     signalF->FixParameter(0, EMCAL()->GetRawFormatHighCharge()) ; 
487     signalF->FixParameter(1, EMCAL()->GetRawFormatHighGain()) ; 
488     Int_t index ; 
489     for (index = 0; index < EMCAL()->GetRawFormatTimeBins(); index++) {
490       gHighGain->GetPoint(index, time, signal) ;               
491       if (signal > kNoiseThreshold && timezero1 == 0.) 
492         timezero1 = time ;
493       if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
494         timezero2 = time ; 
495       if (signal > signalmax) {
496         signalmax = signal ;   
497         timemax   = time ; 
498       }
499     }
500     signalmax /= EMCAL()->RawResponseFunctionMax(EMCAL()->GetRawFormatHighCharge(), 
501                                                 EMCAL()->GetRawFormatHighGain()) ;;
502     if ( timezero1 + EMCAL()->GetRawFormatTimePeak() < EMCAL()->GetRawFormatTimeMax() * 0.4 ) { // else its noise  
503       signalF->SetParameter(2, signalmax) ; 
504       signalF->SetParameter(3, timezero1) ;               
505       gHighGain->Fit(signalF, "QRON", "", 0., timezero2) ; 
506       energy = signalF->GetParameter(2) ; 
507       time   = signalF->GetMaximumX() - EMCAL()->GetRawFormatTimePeak() - EMCAL()->GetRawFormatTimeTrigger() ;
508     }
509   }
510   
511   if (time == 0. && energy == 0.) 
512     amp = 0 ; 
513   else {
514   AliEMCALDigitizer * digitizer = Digitizer() ; 
515   amp = static_cast<Int_t>( (energy - digitizer->GetECApedestal()) / digitizer->GetECAchannel() + 0.5 ) ; 
516   }
517   // dessin
518 //   TCanvas * c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);
519 //   c1->SetFillColor(42);
520 //   c1->SetGrid();
521 //   gLowGain->SetLineColor(2);
522 //   gLowGain->SetLineWidth(4);
523 //   gLowGain->SetMarkerColor(4);
524 //   gLowGain->SetMarkerStyle(21);
525 //   gLowGain->SetTitle("Lowgain");
526 //   gLowGain->GetXaxis()->SetTitle("X title");
527 //   gLowGain->GetYaxis()->SetTitle("Y title");
528 //   gLowGain->Draw("ACP");
529   
530 //   c1->Update();
531 //   c1->GetFrame()->SetFillColor(21);
532 //   c1->GetFrame()->SetBorderSize(12);
533 //   c1->Modified();
534   
535 //   TCanvas * c2 = new TCanvas("c2","A Simple Graph Example",200,10,700,500);
536 //   c2->SetFillColor(42);
537 //   c2->SetGrid();
538 //   gHighGain->SetLineColor(2);
539 //   gHighGain->SetLineWidth(4);
540 //   gHighGain->SetMarkerColor(4);
541 //   gHighGain->SetMarkerStyle(21);
542 //   gHighGain->SetTitle("Highgain");
543 //   gHighGain->GetXaxis()->SetTitle("X title");
544 //   gHighGain->GetYaxis()->SetTitle("Y title");
545 //     gHighGain->Draw("ACP");
546   
547 //   c2->Update();
548 //   c2->GetFrame()->SetFillColor(21);
549 //   c2->GetFrame()->SetBorderSize(12);
550 //   c2->Modified();
551 }
552
553 //____________________________________________________________________________ 
554 Int_t AliEMCALGetter::ReadRaw(Int_t event)
555 {
556   // reads the raw format data, converts it into digits format and store digits in Digits()
557   // container.
558   
559   AliRawReaderFile rawReader(event) ; 
560   AliEMCALRawStream in(&rawReader);
561   
562   Bool_t first = kTRUE ;
563  
564   TF1 * signalF = new TF1("signal", AliEMCAL::RawResponseFunction, 0, EMCAL()->GetRawFormatTimeMax(), 4);
565   signalF->SetParNames("Charge", "Gain", "Amplitude", "TimeZero") ; 
566  
567   
568   Int_t id = -1;
569   Bool_t lowGainFlag = kFALSE ; 
570
571   TClonesArray * digits = Digits() ;
572   digits->Clear() ; 
573   Int_t idigit = 0 ; 
574   Int_t amp = 0 ; 
575   Double_t time = 0. ; 
576
577   TGraph * gLowGain = new TGraph(EMCAL()->GetRawFormatTimeBins()) ; 
578   TGraph * gHighGain= new TGraph(EMCAL()->GetRawFormatTimeBins()) ;  
579
580   while ( in.Next() ) { // EMCAL entries loop 
581     if ( in.IsNewId() ) {
582       if (!first) {
583         FitRaw(lowGainFlag, gLowGain, gHighGain, signalF, amp, time) ; 
584         if (amp > 0) {
585           new((*digits)[idigit]) AliEMCALDigit( -1, -1, id, amp, time) ;        
586           idigit++ ; 
587         }
588         Int_t index ; 
589         for (index = 0; index < EMCAL()->GetRawFormatTimeBins(); index++) {
590           gLowGain->SetPoint(index, index * EMCAL()->GetRawFormatTimeMax() / EMCAL()->GetRawFormatTimeBins(), 0) ;  
591           gHighGain->SetPoint(index, index * EMCAL()->GetRawFormatTimeMax() / EMCAL()->GetRawFormatTimeBins(), 0) ; 
592         } 
593       }  
594       first = kFALSE ; 
595       id = in.GetId() ; 
596       if (in.GetModule() == EMCAL()->GetRawFormatLowGainOffset() ) 
597         lowGainFlag = kTRUE ; 
598       else 
599         lowGainFlag = kFALSE ; 
600     }
601     if (lowGainFlag)
602       gLowGain->SetPoint(in.GetTime(), 
603                          in.GetTime()* EMCAL()->GetRawFormatTimeMax() / EMCAL()->GetRawFormatTimeBins(), 
604                          in.GetSignal()) ;
605     else 
606       gHighGain->SetPoint(in.GetTime(), 
607                           in.GetTime() * EMCAL()->GetRawFormatTimeMax() / EMCAL()->GetRawFormatTimeBins(), 
608                           in.GetSignal() ) ;
609     
610   } // EMCAL entries loop
611   digits->Sort() ; 
612
613   delete signalF ; 
614   delete gLowGain;
615   delete gHighGain ; 
616     
617   return Digits()->GetEntriesFast() ; 
618 }
619   
620   //____________________________________________________________________________ 
621 Int_t AliEMCALGetter::ReadTreeD()
622 {
623   // Read the Digits
624   
625    EmcalLoader()->CleanDigits() ; 
626    EmcalLoader()->LoadDigits("UPDATE") ;
627    EmcalLoader()->LoadDigitizer("UPDATE") ;
628    return Digits()->GetEntries() ; 
629 }
630
631 //____________________________________________________________________________ 
632 Int_t AliEMCALGetter::ReadTreeH()
633 {
634   // Read the Hits
635   EmcalLoader()->CleanHits() ; 
636   // gets TreeH from the root file (EMCAL.Hit.root)
637   //if ( !IsLoaded("H") ) {
638     EmcalLoader()->LoadHits("UPDATE") ;
639     //SetLoaded("H") ; 
640     //}  
641   return Hits()->GetEntries() ; 
642 }
643
644 //____________________________________________________________________________ 
645 Int_t AliEMCALGetter::ReadTreeR()
646 {
647   // Read the RecPoints
648
649    EmcalLoader()->CleanRecPoints() ; 
650   // gets TreeR from the root file (EMCAL.RecPoints.root)
651   //if ( !IsLoaded("R") ) {
652     EmcalLoader()->LoadRecPoints("UPDATE") ;
653     EmcalLoader()->LoadClusterizer("UPDATE") ;
654     //  SetLoaded("R") ; 
655     //}
656
657   return ECARecPoints()->GetEntries() ; 
658 }
659
660 //____________________________________________________________________________ 
661 Int_t AliEMCALGetter::ReadTreeT()
662 {
663   // Read the TrackSegments
664   
665   EmcalLoader()->CleanTracks() ; 
666   // gets TreeT from the root file (EMCAL.TrackSegments.root)
667   //if ( !IsLoaded("T") ) {
668     EmcalLoader()->LoadTracks("UPDATE") ;
669     EmcalLoader()->LoadTrackSegmentMaker("UPDATE") ;
670     //  SetLoaded("T") ; 
671     //}
672
673   return TrackSegments()->GetEntries() ; 
674 }
675 //____________________________________________________________________________ 
676 Int_t AliEMCALGetter::ReadTreeP()
677 {
678   // Read the RecParticles
679   
680   EmcalLoader()->CleanRecParticles() ; 
681   // gets TreeP from the root file (EMCAL.RecParticles.root)
682   //  if ( !IsLoaded("P") ) {
683     EmcalLoader()->LoadRecParticles("UPDATE") ;
684     EmcalLoader()->LoadPID("UPDATE") ;
685     //  SetLoaded("P") ; 
686     // }
687
688   return RecParticles()->GetEntries() ; 
689 }
690 //____________________________________________________________________________ 
691 Int_t AliEMCALGetter::ReadTreeS()
692 {
693   // Read the SDigits
694   
695   //  EmcalLoader()->CleanSDigits() ; 
696   // gets TreeS from the root file (EMCAL.SDigits.root)
697   // if ( !IsLoaded("S") ) {
698     EmcalLoader()->LoadSDigits("READ") ;
699     EmcalLoader()->LoadSDigitizer("READ") ;
700     //  SetLoaded("S") ; 
701     //}
702
703   return SDigits()->GetEntries() ; 
704 }
705
706 //____________________________________________________________________________ 
707 TClonesArray * AliEMCALGetter::SDigits() const  
708 {
709   // asks the Loader to return the Digits container 
710
711   TClonesArray * rv = 0 ; 
712   
713   rv = EmcalLoader()->SDigits() ; 
714   if (!rv) {
715     EmcalLoader()->MakeSDigitsArray() ;
716     rv = EmcalLoader()->SDigits() ; 
717   }
718   return rv ; 
719 }
720
721 //____________________________________________________________________________ 
722 AliEMCALSDigitizer * AliEMCALGetter::SDigitizer() 
723
724   // Return pointer to SDigitizer task
725   AliEMCALSDigitizer * rv ; 
726   rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
727   if (!rv) {
728     Event(0, "S") ; 
729     rv =  dynamic_cast<AliEMCALSDigitizer *>(EmcalLoader()->SDigitizer()) ;
730   }
731   return rv ; 
732 }
733
734 //____________________________________________________________________________ 
735 TParticle * AliEMCALGetter::Secondary(const TParticle* p, Int_t index) const
736 {
737   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
738
739   if(index <= 0) 
740     return 0 ;
741   if(index > 2)
742     return 0 ;
743
744   if(p) {
745   Int_t daughterIndex = p->GetDaughter(index-1) ; 
746   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
747   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ; 
748   }
749   else
750     return 0 ;
751 }
752
753 //____________________________________________________________________________ 
754 void AliEMCALGetter::Track(Int_t itrack) 
755 {
756   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
757  
758  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
759
760   if( !TreeH() ) // load treeH the first time
761     rl->LoadHits() ;
762
763   // first time create the container
764   TClonesArray * hits = Hits() ; 
765   if ( hits ) 
766     hits->Clear() ; 
767
768   TBranch * emcalbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("EMCAL")) ; 
769   emcalbranch->SetAddress(&hits) ;
770   emcalbranch->GetEntry(itrack) ;
771 }
772
773 //____________________________________________________________________________ 
774 TTree * AliEMCALGetter::TreeD() const 
775 {
776   // return pointer to Digits Tree
777   TTree * rv = 0 ; 
778   rv = EmcalLoader()->TreeD() ; 
779   if ( !rv ) {
780     EmcalLoader()->MakeTree("D");
781     rv = EmcalLoader()->TreeD() ;
782   } 
783   
784   return rv ; 
785 }
786
787 //____________________________________________________________________________ 
788 TTree * AliEMCALGetter::TreeH() const 
789 {
790   // return pointer to Hits Tree
791   TTree * rv = 0 ; 
792   rv = EmcalLoader()->TreeH() ; 
793   if ( !rv ) {
794     EmcalLoader()->MakeTree("H");
795     rv = EmcalLoader()->TreeH() ;
796   } 
797   
798   return rv ; 
799 }
800
801 //____________________________________________________________________________ 
802 TTree * AliEMCALGetter::TreeR() const 
803 {
804   // return pointer to RecPoints Tree
805
806   TTree * rv = 0 ; 
807   rv = EmcalLoader()->TreeR() ; 
808   if ( !rv ) {
809     EmcalLoader()->MakeTree("R");
810     rv = EmcalLoader()->TreeR() ;
811   } 
812   
813   return rv ; 
814 }
815
816 //____________________________________________________________________________ 
817 TTree * AliEMCALGetter::TreeT() const 
818 {  
819   // return pointer to TrackSegments Tree
820   TTree * rv = 0 ; 
821   rv = EmcalLoader()->TreeT() ; 
822   if ( !rv ) {
823     EmcalLoader()->MakeTree("T");
824     rv = EmcalLoader()->TreeT() ;
825   } 
826   
827   return rv ; 
828 }
829 //____________________________________________________________________________ 
830 TTree * AliEMCALGetter::TreeP() const 
831 {
832   // return pointer to RecParticles Tree
833   TTree * rv = 0 ; 
834   rv = EmcalLoader()->TreeP() ; 
835   if ( !rv ) {
836     EmcalLoader()->MakeTree("P");
837     rv = EmcalLoader()->TreeP() ;
838   } 
839   
840   return rv ; 
841 }
842
843 //____________________________________________________________________________ 
844 TTree * AliEMCALGetter::TreeS() const 
845 {
846   // return pointer to SDigits Tree
847   TTree * rv = 0 ; 
848   rv = EmcalLoader()->TreeS() ; 
849   if ( !rv ) {
850     EmcalLoader()->MakeTree("S");
851     rv = EmcalLoader()->TreeS() ;
852   } 
853   
854   return rv ; 
855 }
856
857 //____________________________________________________________________________ 
858 Bool_t AliEMCALGetter::VersionExists(TString & opt) const
859 {
860   // checks if the version with the present name already exists in the same directory
861
862   Bool_t rv = kFALSE ;
863  
864   AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
865   TString version( rl->GetEventFolder()->GetName() ) ; 
866
867   opt.ToLower() ; 
868   
869   if ( opt == "sdigits") {
870     // add the version name to the root file name
871     TString fileName( EmcalLoader()->GetSDigitsFileName() ) ; 
872     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
873       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
874     if ( !(gSystem->AccessPathName(fileName)) ) { 
875       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
876       rv = kTRUE ; 
877     }
878     EmcalLoader()->SetSDigitsFileName(fileName) ;
879   }
880
881   if ( opt == "digits") {
882     // add the version name to the root file name
883     TString fileName( EmcalLoader()->GetDigitsFileName() ) ; 
884     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
885       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
886     if ( !(gSystem->AccessPathName(fileName)) ) {
887       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;  
888       rv = kTRUE ; 
889     }
890   }
891
892   return rv ;
893
894 }
895
896 //____________________________________________________________________________ 
897 UShort_t AliEMCALGetter::EventPattern(void) const
898 {
899   // Return the pattern (trigger bit register) of the beam-test event
900 //   if(fBTE)
901 //     return fBTE->GetPattern() ;
902 //   else
903     return 0 ;
904 }
905 //____________________________________________________________________________ 
906 Float_t AliEMCALGetter::BeamEnergy(void) const
907 {
908   // Return the beam energy of the beam-test event
909 //   if(fBTE)
910 //     return fBTE->GetBeamEnergy() ;
911 //   else
912     return 0 ;
913 }