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