AliPHOSGeometry is removed from AliPHOSGetter and AliPHOSLoader
[u/mrichter/AliRoot.git] / PHOS / AliPHOSGetter.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 AliPHOSAnalyser):
28 //  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
29 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
30 //     AliPHOSRecParticle * 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 AliPHOSIndexToObject 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 <TParticle.h>
47 #include <TF1.h>
48 #include <TGraph.h>
49 #include <TCanvas.h>
50 #include <TStyle.h>
51 //#include <TFrame.h>
52
53 // --- Standard library ---
54
55 // --- AliRoot header files ---
56 #include "AliESD.h"
57 #include "AliHeader.h"  
58 #include "AliMC.h"
59 #include "AliPHOS.h"
60 #include "AliPHOSBeamTestEvent.h"
61 #include "AliPHOSGetter.h"
62 #include "AliPHOSLoader.h"
63 #include "AliPHOSPulseGenerator.h"
64 #include "AliRunLoader.h"
65 #include "AliStack.h"  
66 #include "AliPHOSRawDecoder.h"
67 #include "AliRawReaderFile.h"
68 #include "AliLog.h"
69 #include "AliCDBLocal.h"
70 #include "AliCDBStorage.h"
71 #include "AliCDBManager.h"
72 #include "AliPHOSRawDigiProducer.h"
73 #include "AliPHOSReconstructor.h"
74 #include "AliPHOSRecoParam.h"
75
76 ClassImp(AliPHOSGetter)
77   
78 AliPHOSGetter   * AliPHOSGetter::fgObjGetter  = 0 ; 
79 AliPHOSLoader   * AliPHOSGetter::fgPhosLoader = 0;
80 AliPHOSCalibData* AliPHOSGetter::fgCalibData  = 0;
81 Int_t AliPHOSGetter::fgDebug = 0;
82
83 //  TFile * AliPHOSGetter::fgFile = 0 ; 
84
85 AliPHOSGetter::AliPHOSGetter() :
86   fBTE(0),
87   fLoadingStatus(),
88   fNPrimaries(0),
89   fPrimaries(0),
90   fESDFile(0),
91   fESDFileName(),
92   fESD(0),
93   fESDTree(0),
94   fRawDigits(kFALSE),
95   fcdb(0)
96 {
97   // ctor: this is a singleton, the ctor should never be called but cint needs it as public
98   Fatal("ctor", "AliPHOSGetter is a singleton default ctor not callable") ;
99
100
101
102 //____________________________________________________________________________ 
103 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* version, Option_t * openingOption) :
104   fBTE(0),
105   fLoadingStatus(),
106   fNPrimaries(0),
107   fPrimaries(0),
108   fESDFile(0),
109   fESDFileName(),
110   fESD(0),
111   fESDTree(0),
112   fRawDigits(kFALSE),
113   fcdb(0)
114 {
115   // ctor only called by Instance()
116
117   AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ; 
118   if (!rl) {
119     rl = AliRunLoader::Open(headerFile, version, openingOption);
120     if (!rl) {
121       Fatal("AliPHOSGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ; 
122       return ;
123     } 
124     if (rl->GetAliRun() == 0x0) {
125       rl->LoadgAlice();
126       gAlice = rl->GetAliRun(); // should be removed
127       rl->LoadHeader();
128     }
129   }
130   fgPhosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
131   if ( !fgPhosLoader ) 
132     Error("AliPHOSGetter", "Could not find PHOSLoader") ; 
133   else 
134     fgPhosLoader->SetTitle(version);
135   
136   // initialize data members
137   SetDebug(0) ; 
138   fBTE = 0 ; 
139   fPrimaries = 0 ; 
140   fLoadingStatus = "" ; 
141  
142   fESDFileName = rl->GetFileName()  ; // this should be the galice.root file
143   fESDFileName.ReplaceAll("galice.root", "AliESDs.root") ;  
144   fESDFile = 0 ; 
145   fESD = 0 ; 
146   fESDTree = 0 ; 
147   fRawDigits = kFALSE ;
148
149 }
150
151 AliPHOSGetter::AliPHOSGetter(const AliPHOSGetter & obj) :
152   TObject(obj),
153   fBTE(0),
154   fLoadingStatus(),
155   fNPrimaries(0),
156   fPrimaries(0),
157   fESDFile(0),
158   fESDFileName(),
159   fESD(0),
160   fESDTree(0),
161   fRawDigits(kFALSE),
162   fcdb(0)
163 {
164   // cpy ctor requested by Coding Convention 
165   Fatal("cpy ctor", "not implemented") ;
166
167
168 //____________________________________________________________________________ 
169 AliPHOSGetter::AliPHOSGetter(Int_t /*i*/) :
170   fBTE(0),
171   fLoadingStatus(),
172   fNPrimaries(0),
173   fPrimaries(0),
174   fESDFile(0),
175   fESDFileName(),
176   fESD(0),
177   fESDTree(0),
178   fRawDigits(kFALSE),
179   fcdb(0)
180 {
181   // special constructor for onflight 
182
183
184
185 //____________________________________________________________________________ 
186 AliPHOSGetter::~AliPHOSGetter()
187 {
188   // dtor
189   if(fgPhosLoader){
190     delete fgPhosLoader ;
191     fgPhosLoader = 0 ;
192   }
193   if(fBTE){
194     delete fBTE ; 
195     fBTE = 0 ;
196   } 
197   if(fPrimaries){
198     fPrimaries->Delete() ; 
199     delete fPrimaries ;
200   } 
201   if (fESD) 
202     delete fESD ; 
203   if (fESDTree) 
204     delete fESDTree ;
205  
206   fgObjGetter = 0;
207 }
208
209 //____________________________________________________________________________ 
210 void AliPHOSGetter::Reset()
211 {
212   // resets things in case the getter is called consecutively with different files
213   // the PHOS Loader is already deleted by the Run Loader
214
215   if (fPrimaries) { 
216     fPrimaries->Delete() ; 
217     delete fPrimaries ;
218   } 
219   fgPhosLoader = 0; 
220   fgObjGetter = 0; 
221 }
222
223 //____________________________________________________________________________ 
224 AliPHOSClusterizer * AliPHOSGetter::Clusterizer()
225
226   // Returns pointer to the Clusterizer task 
227   AliPHOSClusterizer * rv ; 
228   rv =  dynamic_cast<AliPHOSClusterizer *>(PhosLoader()->Reconstructioner()) ;
229   if (!rv) {
230     Event(0, "R") ; 
231     rv =  dynamic_cast<AliPHOSClusterizer*>(PhosLoader()->Reconstructioner()) ;
232   }
233   return rv ; 
234 }
235
236 //____________________________________________________________________________ 
237 TObjArray * AliPHOSGetter::CpvRecPoints() const
238 {
239   // asks the Loader to return the CPV RecPoints container 
240
241   TObjArray * rv = 0 ; 
242   
243   rv = PhosLoader()->CpvRecPoints() ; 
244   if (!rv) {
245     PhosLoader()->MakeRecPointsArray() ;
246     rv = PhosLoader()->CpvRecPoints() ; 
247   }
248   return rv ; 
249 }
250
251 //____________________________________________________________________________ 
252 TClonesArray * AliPHOSGetter::Digits() const
253 {
254   // asks the Loader to return the Digits container 
255
256   TClonesArray * rv = 0 ; 
257   rv = PhosLoader()->Digits() ; 
258
259   if( !rv ) {
260     PhosLoader()->MakeDigitsArray() ; 
261     rv = PhosLoader()->Digits() ;
262   }
263   return rv ; 
264 }
265
266 //____________________________________________________________________________ 
267 AliPHOSDigitizer * AliPHOSGetter::Digitizer() 
268
269   // Returns pointer to the Digitizer task 
270   AliPHOSDigitizer * rv ; 
271   rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
272   if (!rv) {
273     Event(0, "D") ; 
274     rv =  dynamic_cast<AliPHOSDigitizer *>(PhosLoader()->Digitizer()) ;
275   }
276   return rv ; 
277 }
278
279
280 //____________________________________________________________________________ 
281 TObjArray * AliPHOSGetter::EmcRecPoints() const
282 {
283   // asks the Loader to return the EMC RecPoints container 
284
285   TObjArray * rv = 0 ; 
286   
287   rv = PhosLoader()->EmcRecPoints() ; 
288   if (!rv) {
289     PhosLoader()->MakeRecPointsArray() ;
290     rv = PhosLoader()->EmcRecPoints() ; 
291   }
292   return rv ; 
293 }
294
295 //____________________________________________________________________________ 
296 TClonesArray * AliPHOSGetter::TrackSegments() const
297 {
298   // asks the Loader to return the TrackSegments container 
299
300   TClonesArray * rv = 0 ; 
301   
302   rv = PhosLoader()->TrackSegments() ; 
303   if (!rv) {
304     PhosLoader()->MakeTrackSegmentsArray() ;
305     rv = PhosLoader()->TrackSegments() ; 
306   }
307   return rv ; 
308 }
309
310 //____________________________________________________________________________ 
311 AliPHOSTrackSegmentMaker * AliPHOSGetter::TrackSegmentMaker()
312
313   // Returns pointer to the TrackSegmentMaker task 
314   AliPHOSTrackSegmentMaker * rv ; 
315   rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
316   if (!rv) {
317     Event(0, "T") ; 
318     rv =  dynamic_cast<AliPHOSTrackSegmentMaker *>(PhosLoader()->TrackSegmentMaker()) ;
319   }
320   return rv ; 
321 }
322
323 //____________________________________________________________________________ 
324 TClonesArray * AliPHOSGetter::RecParticles() const
325 {
326   // asks the Loader to return the TrackSegments container 
327
328   TClonesArray * rv = 0 ; 
329   
330   rv = PhosLoader()->RecParticles() ; 
331   if (!rv) {
332     PhosLoader()->MakeRecParticlesArray() ;
333     rv = PhosLoader()->RecParticles() ; 
334   }
335   return rv ; 
336 }
337 //____________________________________________________________________________ 
338 void AliPHOSGetter::Event(Int_t event, const char* opt) 
339 {
340   // Reads the content of all Tree's S, D and R
341
342 //   if ( event >= MaxEvent() ) {
343 //     Error("Event", "%d not found in TreeE !", event) ; 
344 //     return ; 
345 //   }
346
347   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
348
349 //   // checks if we are dealing with test-beam data
350 //   TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
351 //   if(btb){
352 //     if(!fBTE)
353 //       fBTE = new AliPHOSBeamTestEvent() ;
354 //     btb->SetAddress(&fBTE) ;
355 //     btb->GetEntry(event) ;
356 //   }
357 //   else{
358 //     if(fBTE){
359 //       delete fBTE ;
360 //       fBTE = 0 ;
361 //     }
362 //   }
363
364   // Loads the type of object(s) requested
365   
366   rl->GetEvent(event) ;
367
368   if(strstr(opt,"X") || (strcmp(opt,"")==0)){
369     ReadPrimaries() ;
370   }
371   
372   if(strstr(opt,"H")  ){
373     ReadTreeH();
374   }
375   
376   if(strstr(opt,"S")  ){
377     ReadTreeS() ;
378   }
379   
380   if(strstr(opt,"D") ){
381     ReadTreeD() ;
382   }
383   
384   if(strstr(opt,"R") ){
385     ReadTreeR() ;
386   }
387
388   if( strstr(opt,"T") ){
389     ReadTreeT() ;
390   }    
391
392   if( strstr(opt,"P") ){
393     ReadTreeP() ;
394   }    
395
396   if( strstr(opt,"E") ){
397     ReadTreeE(event) ;
398   }
399
400 }
401
402
403 //____________________________________________________________________________ 
404 void AliPHOSGetter::Event(AliRawReader *rawReader, const char* opt, Bool_t isOldRCUFormat) 
405 {
406   // Reads the raw event from rawReader
407   // isOldRCUFormat defines whenever to assume
408   // the old RCU format or not
409   
410   if( strstr(opt,"W")  ){
411     rawReader->NextEvent();
412     ReadRaw(rawReader,isOldRCUFormat) ;
413   }    
414  
415 }
416
417
418 //____________________________________________________________________________ 
419 Int_t AliPHOSGetter::EventNumber() const
420   {
421   // return the current event number
422   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
423   return static_cast<Int_t>(rl->GetEventNumber()) ;   
424 }
425
426 //____________________________________________________________________________ 
427   TClonesArray * AliPHOSGetter::Hits() const
428 {
429   // asks the loader to return  the Hits container 
430   
431   TClonesArray * rv = 0 ; 
432   
433   rv = PhosLoader()->Hits() ; 
434   if ( !rv ) {
435     PhosLoader()->LoadHits("read"); 
436     rv = PhosLoader()->Hits() ; 
437   }
438   return rv ; 
439 }
440
441 //____________________________________________________________________________ 
442 AliPHOSGetter * AliPHOSGetter::Instance(const char* alirunFileName, const char* version, Option_t * openingOption) 
443 {
444   // Creates and returns the pointer of the unique instance
445   // Must be called only when the environment has changed
446   
447   if(!fgObjGetter){ // first time the getter is called 
448     fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
449   }
450   else { // the getter has been called previously
451     AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
452     if ( rl->GetFileName() == alirunFileName ) {// the alirunFile has the same name
453       // check if the file is already open
454       TFile * galiceFile = dynamic_cast<TFile *>(gROOT->FindObject(rl->GetFileName()) ) ; 
455       
456       if ( !galiceFile ) 
457         fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
458       
459       else {  // the file is already open check the version name
460         TString currentVersionName = rl->GetEventFolder()->GetName() ; 
461         TString newVersionName(version) ; 
462         if (currentVersionName == newVersionName) 
463           if(fgDebug)
464             ::Warning( "Instance", "Files with version %s already open", currentVersionName.Data() ) ;  
465         else {
466           fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;      
467         }
468       }
469     }
470     else {
471       rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle()) ; 
472       if ( strstr(version, AliConfig::GetDefaultEventFolderName()) ) // false in case of merging
473         delete rl ; 
474       fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;      
475     }
476   }
477   if (!fgObjGetter) 
478     ::Error("AliPHOSGetter::Instance", "Failed to create the PHOS Getter object") ;
479   else 
480     if (fgDebug)
481       Print() ;
482   
483   return fgObjGetter ;
484 }
485
486 //____________________________________________________________________________ 
487 AliPHOSGetter *  AliPHOSGetter::Instance()
488 {
489   // Returns the pointer of the unique instance already defined
490   
491   if(!fgObjGetter && fgDebug)
492      ::Warning("AliPHOSGetter::Instance", "Getter not initialized") ;
493
494    return fgObjGetter ;
495            
496 }
497
498 //____________________________________________________________________________ 
499 Int_t AliPHOSGetter::MaxEvent() const 
500 {
501   // returns the number of events in the run (from TE)
502
503   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
504   return static_cast<Int_t>(rl->GetNumberOfEvents()) ; 
505 }
506
507 //____________________________________________________________________________ 
508 TParticle * AliPHOSGetter::Primary(Int_t index) const
509 {
510   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
511   return rl->Stack()->Particle(index) ; 
512
513
514 //____________________________________________________________________________ 
515 AliPHOS * AliPHOSGetter:: PHOS() const  
516 {
517   // returns the PHOS object 
518   AliPHOSLoader *    loader = 0;
519   static AliPHOSLoader * oldloader = 0;
520   static AliPHOS * phos = 0;
521
522   loader = PhosLoader();
523
524   if ( loader != oldloader) {
525     phos = dynamic_cast<AliPHOS*>(loader->GetModulesFolder()->FindObject("PHOS")) ;
526     oldloader = loader;
527   }
528   if (!phos) 
529     if (fgDebug)
530       Warning("PHOS", "PHOS module not found in module folders: %s", PhosLoader()->GetModulesFolder()->GetName() ) ; 
531   return phos ; 
532 }  
533
534
535
536 //____________________________________________________________________________ 
537 AliPHOSPID * AliPHOSGetter::PID()
538
539   // Returns pointer to the PID task 
540   AliPHOSPID * rv ; 
541   rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
542   if (!rv) {
543     Event(0, "P") ; 
544     rv =  dynamic_cast<AliPHOSPID *>(PhosLoader()->PIDTask()) ;
545   }
546   return rv ; 
547 }
548
549 //____________________________________________________________________________ 
550 TClonesArray * AliPHOSGetter::Primaries()  
551 {
552   // creates the Primaries container if needed
553   if ( !fPrimaries ) {
554     if (fgDebug) 
555       Info("Primaries", "Creating a new TClonesArray for primaries") ; 
556     fPrimaries = new TClonesArray("TParticle", 1000) ;
557   } 
558   return fPrimaries ; 
559 }
560
561 //____________________________________________________________________________ 
562 void  AliPHOSGetter::Print() 
563 {
564   // Print usefull information about the getter
565     
566   AliRunLoader * rl = AliRunLoader::GetRunLoader(fgPhosLoader->GetTitle());
567   ::Info( "Print", "gAlice file is %s -- version name is %s", (rl->GetFileName()).Data(), rl->GetEventFolder()->GetName() ) ; 
568 }
569
570 //____________________________________________________________________________ 
571 void AliPHOSGetter::ReadPrimaries()  
572 {
573   // Read Primaries from Kinematics.root
574   
575   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
576   
577   // gets kine tree from the root file (Kinematics.root)
578   if ( ! rl->TreeK() ) { // load treeK the first time
579     rl->LoadKinematics() ;
580   }
581   
582   fNPrimaries = (rl->GetHeader())->GetNtrack(); 
583   if (fgDebug) 
584     Info( "ReadTreeK", "Found %d particles in event # %d", fNPrimaries, EventNumber() ) ; 
585
586
587   // first time creates the container
588   if ( Primaries() ) 
589     fPrimaries->Clear() ; 
590   
591   Int_t index = 0 ; 
592   for (index = 0 ; index < fNPrimaries; index++) { 
593     new ((*fPrimaries)[index]) TParticle(*(Primary(index)));
594   }
595 }
596
597 //____________________________________________________________________________ 
598 Bool_t AliPHOSGetter::OpenESDFile() 
599 {
600   //Open the ESD file    
601   Bool_t rv = kTRUE ; 
602   if (!fESDFile) {
603     fESDFile = TFile::Open(fESDFileName) ;
604     if (!fESDFile ) 
605       return kFALSE ; 
606   }
607   else if (fESDFile->IsOpen()) {
608     fESDFile->Close() ; 
609     fESDFile = TFile::Open(fESDFileName) ;
610   }
611   if (!fESDFile->IsOpen())
612     rv = kFALSE ; 
613   return rv ; 
614 }
615
616 //____________________________________________________________________________ 
617 void AliPHOSGetter::FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Double_t & energy, Double_t & time) const
618 {
619   // Fits the raw signal time distribution 
620
621   const Int_t kNoiseThreshold = 0 ;
622   Double_t timezero1 = 0., timezero2 = 0., timemax = 0. ;
623   Double_t signal = 0., signalmax = 0. ;       
624   time   = 0. ; 
625   energy = 0. ; 
626
627   // Create a shaper pulse object which contains all the shaper parameters
628   AliPHOSPulseGenerator pulse;
629
630   if (lowGainFlag) {
631     timezero1 = timezero2 = signalmax = timemax = 0. ;
632     signalF->FixParameter(0, pulse.GetRawFormatLowCharge()) ; 
633     signalF->FixParameter(1, pulse.GetRawFormatLowGain()) ; 
634     Int_t index ; 
635     for (index = 0; index < pulse.GetRawFormatTimeBins(); index++) {
636       gLowGain->GetPoint(index, time, signal) ; 
637       if (signal > kNoiseThreshold && timezero1 == 0.) 
638         timezero1 = time ;
639       if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
640         timezero2 = time ; 
641       if (signal > signalmax) {
642         signalmax = signal ; 
643         timemax   = time ; 
644       }
645     }
646     signalmax /= 
647       pulse.RawResponseFunctionMax(pulse.GetRawFormatLowCharge(), 
648                                    pulse.GetRawFormatLowGain()) ;
649     if ( timezero1 + pulse.GetRawFormatTimePeak() < pulse.GetRawFormatTimeMax() * 0.4 ) { // else its noise 
650       signalF->SetParameter(2, signalmax) ; 
651       signalF->SetParameter(3, timezero1) ;         
652       gLowGain->Fit(signalF, "QRO", "", 0., timezero2); //, "QRON") ; 
653       energy = signalF->GetParameter(2) ; 
654       time   = signalF->GetMaximumX() - pulse.GetRawFormatTimePeak() - pulse.GetRawFormatTimeTrigger() ;
655     }
656   } else {
657     timezero1 = timezero2 = signalmax = timemax = 0. ;
658     signalF->FixParameter(0, pulse.GetRawFormatHighCharge()) ; 
659     signalF->FixParameter(1, pulse.GetRawFormatHighGain()) ; 
660     Int_t index ; 
661     for (index = 0; index < pulse.GetRawFormatTimeBins(); index++) {
662       gHighGain->GetPoint(index, time, signal) ;               
663       if (signal > kNoiseThreshold && timezero1 == 0.) 
664         timezero1 = time ;
665       if (signal <= kNoiseThreshold && timezero1 > 0. && timezero2 == 0.)
666         timezero2 = time ; 
667       if (signal > signalmax) {
668         signalmax = signal ;   
669         timemax   = time ; 
670       }
671     }
672     signalmax /= pulse.RawResponseFunctionMax(pulse.GetRawFormatHighCharge(), 
673                                               pulse.GetRawFormatHighGain()) ;;
674     if ( timezero1 + pulse.GetRawFormatTimePeak() < pulse.GetRawFormatTimeMax() * 0.4 ) { // else its noise  
675       signalF->SetParameter(2, signalmax) ; 
676       signalF->SetParameter(3, timezero1) ;               
677       gHighGain->Fit(signalF, "QRO", "", 0., timezero2) ; 
678       energy = signalF->GetParameter(2) ; 
679       time   = signalF->GetMaximumX() - pulse.GetRawFormatTimePeak() - pulse.GetRawFormatTimeTrigger() ;
680     }
681   }
682   if (time == 0) energy = 0 ; 
683 }
684
685 //____________________________________________________________________________ 
686 Int_t AliPHOSGetter::CalibrateRaw(Double_t energy, Int_t *relId)
687 {
688   // Convert energy into digitized amplitude for a cell relId
689   // It is a user responsilibity to open CDB and set
690   // AliPHOSCalibData object by the following operators:
691   // 
692   // AliCDBLocal *loc = new AliCDBLocal("deCalibDB");
693   // AliPHOSCalibData* clb = (AliPHOSCalibData*)AliCDBStorage::Instance()
694   //    ->Get(path_to_calibdata,run_number);
695   // AliPHOSGetter* gime = AliPHOSGetter::Instance("galice.root");
696   // gime->SetCalibData(clb);
697
698   if (CalibData() == 0)
699     Warning("CalibrateRaw","Calibration DB is not initiated!");
700
701   Int_t   module = relId[0];
702   Int_t   column = relId[3];
703   Int_t   row    = relId[2];
704
705   Float_t gainFactor = 0.0015; // width of one Emc ADC channel in GeV
706   Float_t pedestal   = 0.005;  // Emc pedestals
707
708   if(CalibData()) {
709     gainFactor = CalibData()->GetADCchannelEmc (module,column,row);
710     pedestal   = CalibData()->GetADCpedestalEmc(module,column,row);
711   }
712   
713   Int_t   amp = static_cast<Int_t>( (energy - pedestal) / gainFactor + 0.5 ) ; 
714   return amp;
715 }
716 //____________________________________________________________________________ 
717 Int_t AliPHOSGetter::ReadRaw(AliRawReader *rawReader,Bool_t isOldRCUFormat)
718 {
719   // reads the raw format data, converts it into digits format and store digits in Digits()
720   // container.
721   // isOldRCUFormat = kTRUE in case of the old RCU
722   // format used in the raw data readout.
723   // Reimplemented by Boris Polichtchouk (Jul 2006)
724   // to make it working with the Jul-Aug 2006 beam test data.
725  
726   //Create raw decoder.
727
728   AliPHOSRawDecoder dc(rawReader);
729   dc.SetOldRCUFormat(isOldRCUFormat);
730   dc.SubtractPedestals(AliPHOSReconstructor::GetRecoParamEmc()->SubtractPedestals());
731
732   TClonesArray * digits = Digits() ;
733   AliPHOSRawDigiProducer pr;
734   pr.MakeDigits(digits,&dc);
735   
736   //ADC counts -> GeV
737   for(Int_t i=0; i<digits->GetEntries(); i++) {
738     AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(i);
739     digit->SetEnergy(digit->GetEnergy()/AliPHOSPulseGenerator::GeV2ADC());
740   }
741   
742   //!!!!for debug!!!
743   Int_t modMax=-111;
744   Int_t colMax=-111;
745   Int_t rowMax=-111;
746   Float_t eMax=-333;
747   //!!!for debug!!!
748
749   AliPHOSGeometry * phosgeom =  AliPHOSGeometry::GetInstance() ;
750   Int_t relId[4];
751   for(Int_t iDigit=0; iDigit<digits->GetEntries(); iDigit++) {
752     AliPHOSDigit* digit = (AliPHOSDigit*)digits->At(iDigit);
753     if(digit->GetEnergy()>eMax) {
754       phosgeom->AbsToRelNumbering(digit->GetId(),relId);
755       eMax=digit->GetEnergy();
756       modMax=relId[0];
757       rowMax=relId[2];
758       colMax=relId[3];
759     }
760   }
761
762   AliDebug(1,Form("Digit with max. energy:  modMax %d colMax %d rowMax %d  eMax %f\n\n",
763                   modMax,colMax,rowMax,eMax));
764
765   return digits->GetEntriesFast() ; 
766 }
767
768 //____________________________________________________________________________ 
769 Int_t AliPHOSGetter::ReadTreeD() const
770 {
771   // Read the Digits
772   
773   PhosLoader()->CleanDigits() ;    
774   PhosLoader()->LoadDigits("UPDATE") ;
775   PhosLoader()->LoadDigitizer("UPDATE") ;
776   return Digits()->GetEntries() ; 
777 }
778
779 //____________________________________________________________________________ 
780 Int_t AliPHOSGetter::ReadTreeH() const
781 {
782   // Read the Hits
783   PhosLoader()->CleanHits() ;
784   // gets TreeH from the root file (PHOS.Hit.root)
785   //if ( !IsLoaded("H") ) {
786     PhosLoader()->LoadHits("UPDATE") ;
787   //  SetLoaded("H") ; 
788   //}  
789   return Hits()->GetEntries() ; 
790 }
791
792 //____________________________________________________________________________ 
793 Int_t AliPHOSGetter::ReadTreeR() const
794 {
795   // Read the RecPoints
796   
797   PhosLoader()->CleanRecPoints() ;
798   // gets TreeR from the root file (PHOS.RecPoints.root)
799   //if ( !IsLoaded("R") ) {
800     PhosLoader()->LoadRecPoints("UPDATE") ;
801     //  SetLoaded("R") ; 
802     //}
803
804   return EmcRecPoints()->GetEntries() ; 
805 }
806
807 //____________________________________________________________________________ 
808 Int_t AliPHOSGetter::ReadTreeT() const
809 {
810   // Read the TrackSegments
811   
812   PhosLoader()->CleanTracks() ; 
813   // gets TreeT from the root file (PHOS.TrackSegments.root)
814   //if ( !IsLoaded("T") ) {
815     PhosLoader()->LoadTracks("UPDATE") ;
816     PhosLoader()->LoadTrackSegmentMaker("UPDATE") ;
817     //    SetLoaded("T") ; 
818     //}
819
820   return TrackSegments()->GetEntries() ; 
821 }
822 //____________________________________________________________________________ 
823 Int_t AliPHOSGetter::ReadTreeP() const
824 {
825   // Read the RecParticles
826   
827   PhosLoader()->CleanRecParticles() ; 
828
829   // gets TreeT from the root file (PHOS.TrackSegments.root)
830   //  if ( !IsLoaded("P") ) {
831     PhosLoader()->LoadRecParticles("UPDATE") ;
832     PhosLoader()->LoadPID("UPDATE") ;
833     //  SetLoaded("P") ; 
834     //}
835
836   return RecParticles()->GetEntries() ; 
837 }
838 //____________________________________________________________________________ 
839 Int_t AliPHOSGetter::ReadTreeS() const
840 {
841   // Read the SDigits
842   
843   PhosLoader()->CleanSDigits() ; 
844   // gets TreeS from the root file (PHOS.SDigits.root)
845   //if ( !IsLoaded("S") ) {
846     PhosLoader()->LoadSDigits("READ") ;
847     PhosLoader()->LoadSDigitizer("READ") ;
848     //  SetLoaded("S") ; 
849     //}
850
851   return SDigits()->GetEntries() ; 
852 }
853
854 //____________________________________________________________________________ 
855 Int_t AliPHOSGetter::ReadTreeE(Int_t event)
856 {
857   // Read the ESD
858   
859   // gets esdTree from the root file (AliESDs.root)
860   if (!fESDFile)
861     if ( !OpenESDFile() ) 
862       return -1 ; 
863
864   fESDTree = static_cast<TTree*>(fESDFile->Get("esdTree")) ; 
865   fESD = new AliESD;
866    if (!fESDTree) {
867
868      Error("ReadTreeE", "no ESD tree found");
869      return -1;
870    }
871    fESDTree->SetBranchAddress("ESD", &fESD);
872    fESDTree->GetEvent(event);
873
874    return event ; 
875 }
876
877 //____________________________________________________________________________ 
878 TClonesArray * AliPHOSGetter::SDigits() const
879 {
880   // asks the Loader to return the Digits container 
881
882   TClonesArray * rv = 0 ; 
883   
884   rv = PhosLoader()->SDigits() ; 
885   if (!rv) {
886     PhosLoader()->MakeSDigitsArray() ;
887     rv = PhosLoader()->SDigits() ; 
888   }
889   return rv ; 
890 }
891
892 //____________________________________________________________________________ 
893 AliPHOSSDigitizer * AliPHOSGetter::SDigitizer()
894
895   // Returns pointer to the SDigitizer task 
896   AliPHOSSDigitizer * rv ; 
897   rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
898   if (!rv) {
899     Event(0, "S") ; 
900     rv =  dynamic_cast<AliPHOSSDigitizer *>(PhosLoader()->SDigitizer()) ;
901   }
902   return rv ; 
903 }
904
905 //____________________________________________________________________________ 
906 TParticle * AliPHOSGetter::Secondary(const TParticle* p, Int_t index) const
907 {
908   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
909
910   if(index <= 0) 
911     return 0 ;
912   if(index > 2)
913     return 0 ;
914
915   if(p) {
916   Int_t daughterIndex = p->GetDaughter(index-1) ; 
917   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
918   return  rl->GetAliRun()->GetMCApp()->Particle(daughterIndex) ; 
919   }
920   else
921     return 0 ;
922 }
923
924 //____________________________________________________________________________ 
925 void AliPHOSGetter::Track(Int_t itrack) 
926 {
927   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
928  
929  AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
930
931   if( !TreeH() ) // load treeH the first time
932     rl->LoadHits() ;
933
934   // first time create the container
935   TClonesArray * hits = Hits() ; 
936   if ( hits ) 
937     hits->Clear() ; 
938
939   TBranch * phosbranch = dynamic_cast<TBranch*>(TreeH()->GetBranch("PHOS")) ; 
940   phosbranch->SetAddress(&hits) ;
941   phosbranch->GetEntry(itrack) ;
942 }
943
944 //____________________________________________________________________________ 
945 TTree * AliPHOSGetter::TreeD() const 
946 {
947   // Returns pointer to the Digits Tree
948   TTree * rv = 0 ; 
949   rv = PhosLoader()->TreeD() ; 
950   if ( !rv ) {
951     PhosLoader()->MakeTree("D");
952     rv = PhosLoader()->TreeD() ;
953   } 
954   
955   return rv ; 
956 }
957
958 //____________________________________________________________________________ 
959 TTree * AliPHOSGetter::TreeH() const 
960 {
961   // Returns pointer to the Hits Tree
962   TTree * rv = 0 ; 
963   rv = PhosLoader()->TreeH() ; 
964   if ( !rv ) {
965     PhosLoader()->MakeTree("H");
966     rv = PhosLoader()->TreeH() ;
967   } 
968   
969   return rv ; 
970 }
971
972 //____________________________________________________________________________ 
973 TTree * AliPHOSGetter::TreeR() const 
974 {
975   // Returns pointer to the RecPoints Tree
976   TTree * rv = 0 ; 
977   rv = PhosLoader()->TreeR() ; 
978   if ( !rv ) {
979     PhosLoader()->MakeTree("R");
980     rv = PhosLoader()->TreeR() ;
981   } 
982   
983   return rv ; 
984 }
985
986 //____________________________________________________________________________ 
987 TTree * AliPHOSGetter::TreeT() const 
988 {
989   // Returns pointer to the TrackSegments Tree
990   TTree * rv = 0 ; 
991   rv = PhosLoader()->TreeT() ; 
992   if ( !rv ) {
993     PhosLoader()->MakeTree("T");
994     rv = PhosLoader()->TreeT() ;
995   } 
996   
997   return rv ; 
998 }
999 //____________________________________________________________________________ 
1000 TTree * AliPHOSGetter::TreeP() const 
1001 {
1002   // Returns pointer to the RecParticles  Tree
1003   TTree * rv = 0 ; 
1004   rv = PhosLoader()->TreeP() ; 
1005   if ( !rv ) {
1006     PhosLoader()->MakeTree("P");
1007     rv = PhosLoader()->TreeP() ;
1008   } 
1009   
1010   return rv ; 
1011 }
1012
1013 //____________________________________________________________________________ 
1014 TTree * AliPHOSGetter::TreeS() const 
1015
1016  // Returns pointer to the SDigits Tree
1017   TTree * rv = 0 ; 
1018   rv = PhosLoader()->TreeS() ; 
1019   if ( !rv ) {
1020     PhosLoader()->MakeTree("S");
1021     rv = PhosLoader()->TreeS() ;
1022   } 
1023   
1024   return rv ; 
1025 }
1026
1027 //____________________________________________________________________________ 
1028 Bool_t AliPHOSGetter::VersionExists(TString & opt) const
1029 {
1030   // checks if the version with the present name already exists in the same directory
1031
1032   Bool_t rv = kFALSE ;
1033  
1034   AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
1035   TString version( rl->GetEventFolder()->GetName() ) ; 
1036
1037   opt.ToLower() ; 
1038   
1039   if ( opt == "sdigits") {
1040     // add the version name to the root file name
1041     TString fileName( PhosLoader()->GetSDigitsFileName() ) ; 
1042     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
1043       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
1044     if ( !(gSystem->AccessPathName(fileName)) ) { 
1045       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;
1046       rv = kTRUE ; 
1047     }
1048     PhosLoader()->SetSDigitsFileName(fileName) ;
1049   }
1050
1051   if ( opt == "digits") {
1052     // add the version name to the root file name
1053     TString fileName( PhosLoader()->GetDigitsFileName() ) ; 
1054     if (version != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
1055       fileName = fileName.ReplaceAll(".root", "") + "_" + version + ".root" ;
1056     if ( !(gSystem->AccessPathName(fileName)) ) {
1057       Warning("VersionExists", "The file %s already exists", fileName.Data()) ;  
1058       rv = kTRUE ; 
1059     }
1060   }
1061
1062   return rv ;
1063
1064 }
1065
1066 //____________________________________________________________________________ 
1067 UShort_t AliPHOSGetter::EventPattern(void) const
1068 {
1069   // Return the pattern (trigger bit register) of the beam-test event
1070   if(fBTE)
1071     return fBTE->GetPattern() ;
1072   else
1073     return 0 ;
1074 }
1075 //____________________________________________________________________________ 
1076 Float_t AliPHOSGetter::BeamEnergy(void) const
1077 {
1078   // Return the beam energy of the beam-test event
1079   if(fBTE)
1080     return fBTE->GetBeamEnergy() ;
1081   else
1082     return 0 ;
1083 }
1084 //____________________________________________________________________________ 
1085
1086 AliPHOSCalibData* AliPHOSGetter::CalibData()
1087
1088   // Check if the instance of AliPHOSCalibData exists, and return it
1089
1090   return fgCalibData;
1091 }