de9983a147bd16d7391ab273846b62808d70275d
[u/mrichter/AliRoot.git] / PHOS / AliPHOSDigitizer.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 //_________________________________________________________________________
20 //*-- Author :  Dmitri Peressounko (SUBATECH & Kurchatov Institute) 
21 //////////////////////////////////////////////////////////////////////////////
22 // This TTask performs digitization of Summable digits (in the PHOS case it is just
23 // the sum of contributions from all primary particles into a given cell). 
24 // In addition it performs mixing of summable digits from different events.
25 // The name of the TTask is also the title of the branch that will contain 
26 // the created SDigits
27 // The title of the TTAsk is the name of the file that contains the hits from
28 // which the SDigits are created
29 //
30 // For each event two branches are created in TreeD:
31 //   "PHOS" - list of digits
32 //   "AliPHOSDigitizer" - AliPHOSDigitizer with all parameters used in digitization
33 //
34 // Note, that one can set a title for new digits branch, and repeat digitization with
35 // another set of parameters.
36 //
37 // Use case:
38 // root[0] AliPHOSDigitizer * d = new AliPHOSDigitizer() ;
39 // root[1] d->ExecuteTask()             
40 // Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
41 //                       //Digitizes SDigitis in all events found in file galice.root 
42 //
43 // root[2] AliPHOSDigitizer * d1 = new AliPHOSDigitizer("galice1.root") ;  
44 //                       // Will read sdigits from galice1.root
45 // root[3] d1->MixWith("galice2.root")       
46 // Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
47 //                       // Reads another set of sdigits from galice2.root
48 // root[3] d1->MixWith("galice3.root")       
49 //                       // Reads another set of sdigits from galice3.root
50 // root[4] d->ExecuteTask("deb timing")    
51 //                       // Reads SDigits from files galice1.root, galice2.root ....
52 //                       // mixes them and stores produced Digits in file galice1.root          
53 //                       // deb - prints number of produced digits
54 //                       // deb all - prints list of produced digits
55 //                       // timing  - prints time used for digitization
56 //
57
58 // --- ROOT system ---
59 #include "TFile.h"
60 #include "TTree.h"
61 #include "TSystem.h"
62 #include "TROOT.h"
63 #include "TFolder.h"
64 #include "TObjString.h"
65 #include "TGeometry.h"
66 #include "TBenchmark.h"
67
68 // --- Standard library ---
69
70 // --- AliRoot header files ---
71 #include "AliRun.h"
72 #include "AliHeader.h"
73 #include "AliStream.h"
74 #include "AliRunDigitizer.h"
75 #include "AliPHOSDigit.h"
76 #include "AliPHOS.h"
77 #include "AliPHOSGetter.h"
78 #include "AliPHOSDigitizer.h"
79 #include "AliPHOSSDigitizer.h"
80 #include "AliPHOSGeometry.h"
81 #include "AliPHOSTick.h"
82
83 ClassImp(AliPHOSDigitizer)
84
85
86 //____________________________________________________________________________ 
87   AliPHOSDigitizer::AliPHOSDigitizer():AliDigitizer("",""),
88                                        fInput(0),
89                                        fInputFileNames(0x0),
90                                        fEventNames(0x0)
91 {
92   // ctor
93   InitParameters() ; 
94   fDefaultInit = kTRUE ;
95   fManager = 0 ;                     // We work in the standalong mode
96   fEventFolderName = "" ; 
97 }
98
99 //____________________________________________________________________________ 
100 AliPHOSDigitizer::AliPHOSDigitizer(const TString alirunFileName, const TString eventFolderName):
101   AliDigitizer("PHOS"+AliConfig::fgkDigitizerTaskName, alirunFileName),
102   fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
103 {
104   // ctor
105
106   InitParameters() ; 
107   Init() ;
108   fDefaultInit = kFALSE ; 
109   fManager = 0 ;                     // We work in the standalong mode
110 }
111
112 //____________________________________________________________________________ 
113 AliPHOSDigitizer::AliPHOSDigitizer(const AliPHOSDigitizer & d)
114   : AliDigitizer(d)
115 {
116   // copyy ctor 
117
118   SetName(d.GetName()) ; 
119   SetTitle(d.GetTitle()) ; 
120   fPinNoise = d.fPinNoise ; 
121   fEMCDigitThreshold = d.fEMCDigitThreshold ; 
122   fCPVNoise          = d.fCPVNoise ; 
123   fCPVDigitThreshold = d.fCPVDigitThreshold ; 
124   fTimeResolution    = d.fTimeResolution ; 
125   fTimeThreshold     = d.fTimeThreshold ; 
126   fTimeSignalLength  = d.fTimeSignalLength ; 
127   fADCchanelEmc      = d.fADCchanelEmc ; 
128   fADCpedestalEmc    = d.fADCpedestalEmc ; 
129   fNADCemc           = d.fNADCemc ;
130   fADCchanelCpv      = d.fADCchanelCpv ;
131   fADCpedestalCpv    = d.fADCpedestalCpv ;
132   fNADCcpv           = d.fNADCcpv ; 
133   fEventFolderName   = d.fEventFolderName;
134 }
135
136 //____________________________________________________________________________ 
137 AliPHOSDigitizer::AliPHOSDigitizer(AliRunDigitizer * rd):
138  AliDigitizer(rd,"PHOS"+AliConfig::fgkDigitizerTaskName),
139  fEventFolderName(0)
140 {
141   // ctor
142   fManager = rd ; 
143   SetName(fManager->GetInputFolderName(0)) ;
144   // take title as name of stream 0
145   SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
146   InitParameters() ; 
147   Init() ; 
148   fDefaultInit = kFALSE ; 
149 }
150
151 //____________________________________________________________________________ 
152   AliPHOSDigitizer::~AliPHOSDigitizer()
153 {
154   // dtor
155   delete [] fInputFileNames ; 
156   delete [] fEventNames ; 
157  
158 }
159
160 //____________________________________________________________________________
161 void AliPHOSDigitizer::Digitize(const Int_t event) 
162
163   
164   // Makes the digitization of the collected summable digits.
165   //  It first creates the array of all PHOS modules
166   //  filled with noise (different for EMC, CPV and PPSD) and
167   //  then adds contributions from SDigits. 
168   // This design avoids scanning over the list of digits to add 
169   // contribution to new SDigits only.
170
171   AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
172   TClonesArray * digits = gime->Digits() ; 
173   digits->Clear() ;
174
175   const AliPHOSGeometry *geom = gime->PHOSGeometry() ; 
176   //Making digits with noise, first EMC
177   Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ();
178   
179   Int_t nCPV ;
180   Int_t absID ;
181   
182   nCPV = nEMC + geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() * geom->GetNModules() ;
183   
184   digits->Expand(nCPV) ;
185
186   // get first the sdigitizer from the tasks list 
187   if ( !gime->SDigitizer() ) 
188     gime->LoadSDigitizer();
189   AliPHOSSDigitizer * sDigitizer = gime->SDigitizer(); 
190
191   if ( !sDigitizer )
192     Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
193
194   //take all the inputs to add together and load the SDigits
195   TObjArray * sdigArray = new TObjArray(fInput) ;
196   sdigArray->AddAt(gime->SDigits(), 0) ;
197   Int_t i ;
198   for(i = 1 ; i < fInput ; i++){
199     TString tempo(fEventNames[i]) ; 
200     tempo += i ;
201     AliPHOSGetter * gime = AliPHOSGetter::Instance(fInputFileNames[i], tempo) ; 
202     gime->Event(event,"S");
203     sdigArray->AddAt(gime->SDigits(), i) ;
204   }
205
206   //Find the first crystall with signal
207   Int_t nextSig = 200000 ; 
208   TClonesArray * sdigits ;  
209   for(i = 0 ; i < fInput ; i++){
210     sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
211     if ( !sdigits->GetEntriesFast() )
212       continue ; 
213     Int_t curNext = dynamic_cast<AliPHOSDigit *>(sdigits->At(0))->GetId() ;
214     if(curNext < nextSig) 
215       nextSig = curNext ;
216   }
217   
218   TArrayI index(fInput) ;
219   index.Reset() ;  //Set all indexes to zero
220   
221   AliPHOSDigit * digit ;
222   AliPHOSDigit * curSDigit ;
223   
224   TClonesArray * ticks = new TClonesArray("AliPHOSTick",1000) ;
225   
226   //Put Noise contribution
227   for(absID = 1 ; absID <= nEMC ; absID++){
228     Float_t noise = gRandom->Gaus(0., fPinNoise) ; 
229     new((*digits)[absID-1]) AliPHOSDigit( -1, absID, sDigitizer->Digitize(noise), TimeOfNoise() ) ;
230     //look if we have to add signal?
231     digit = dynamic_cast<AliPHOSDigit *>(digits->At(absID-1)) ;
232     
233     if(absID==nextSig){
234       //Add SDigits from all inputs 
235       ticks->Clear() ;
236       Int_t contrib = 0 ;
237       Float_t a = digit->GetAmp() ;
238       Float_t b = TMath::Abs( a / fTimeSignalLength) ;
239       //Mark the beginning of the signal
240       new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime(),0, b);  
241       //Mark the end of the ignal     
242       new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime()+fTimeSignalLength, -a, -b); 
243       
244       //loop over inputs
245       for(i = 0 ; i < fInput ; i++){
246         if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
247           curSDigit = dynamic_cast<AliPHOSDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;       
248         else
249           curSDigit = 0 ;
250         //May be several digits will contribute from the same input
251         while(curSDigit && curSDigit->GetId() == absID){           
252           //Shift primary to separate primaries belonging different inputs
253           Int_t primaryoffset ;
254           if(fManager)
255             primaryoffset = fManager->GetMask(i) ; 
256           else
257             primaryoffset = 10000000*i ;
258           curSDigit->ShiftPrimary(primaryoffset) ;
259           
260           a = curSDigit->GetAmp() ;
261           b = a /fTimeSignalLength ;
262           new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime(),0, b);  
263           new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b); 
264           
265           *digit = *digit + *curSDigit ;  //add energies
266           
267           index[i]++ ;
268           if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
269             curSDigit = dynamic_cast<AliPHOSDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;     
270           else
271             curSDigit = 0 ;
272         }
273       }
274       
275       //calculate and set time
276       Float_t time = FrontEdgeTime(ticks) ;
277       digit->SetTime(time) ;
278       
279       //Find next signal module
280       nextSig = 200000 ;
281       for(i = 0 ; i < fInput ; i++){
282         sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
283         Int_t curNext = nextSig ;
284         if(sdigits->GetEntriesFast() > index[i] ){
285           curNext = dynamic_cast<AliPHOSDigit *>(sdigits->At(index[i]))->GetId() ;
286         }
287         if(curNext < nextSig) nextSig = curNext ;
288       }
289     }
290   }
291   
292   ticks->Delete() ;
293   delete ticks ;
294   
295   //Now CPV digits (different noise and no timing)
296   for(absID = nEMC+1; absID <= nCPV; absID++){
297     Float_t noise = gRandom->Gaus(0., fCPVNoise) ; 
298     new((*digits)[absID-1]) AliPHOSDigit( -1,absID,sDigitizer->Digitize(noise), TimeOfNoise() ) ;
299     //look if we have to add signal?
300     if(absID==nextSig){
301       digit = dynamic_cast<AliPHOSDigit *>(digits->At(absID-1)) ;
302       //Add SDigits from all inputs
303       for(i = 0 ; i < fInput ; i++){
304         if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
305           curSDigit = dynamic_cast<AliPHOSDigit*>( dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;      
306         else
307           curSDigit = 0 ;
308
309         //May be several digits will contribute from the same input
310         while(curSDigit && curSDigit->GetId() == absID){           
311           //Shift primary to separate primaries belonging different inputs
312           Int_t primaryoffset ;
313           if(fManager)
314             primaryoffset = fManager->GetMask(i) ; 
315           else
316             primaryoffset = 10000000*i ;
317           curSDigit->ShiftPrimary(primaryoffset) ;
318
319           //add energies
320           *digit = *digit + *curSDigit ;  
321           index[i]++ ;
322           if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
323             curSDigit = dynamic_cast<AliPHOSDigit*>( dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i]) ) ;   
324           else
325             curSDigit = 0 ;
326         }
327       }
328
329       //Find next signal module
330       nextSig = 200000 ;
331       for(i = 0 ; i < fInput ; i++){
332         sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
333         Int_t curNext = nextSig ;
334         if(sdigits->GetEntriesFast() > index[i] )
335           curNext = dynamic_cast<AliPHOSDigit *>( sdigits->At(index[i]) )->GetId() ;
336         if(curNext < nextSig) nextSig = curNext ;
337       }
338       
339     }
340   }
341
342   delete sdigArray ; //We should not delete its contents 
343   
344   //remove digits below thresholds
345   for(i = 0 ; i < nEMC ; i++){
346     digit = dynamic_cast<AliPHOSDigit*>( digits->At(i) ) ;
347     if(sDigitizer->Calibrate( digit->GetAmp() ) < fEMCDigitThreshold)
348       digits->RemoveAt(i) ;
349     else
350       digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
351   }
352
353
354   for(i = nEMC; i < nCPV ; i++)
355     if( sDigitizer->Calibrate( dynamic_cast<AliPHOSDigit*>(digits->At(i))->GetAmp() ) < fCPVDigitThreshold )
356       digits->RemoveAt(i) ;
357     
358   digits->Compress() ;  
359   
360   Int_t ndigits = digits->GetEntriesFast() ;
361   digits->Expand(ndigits) ;
362
363   //Set indexes in list of digits and make true digitization of the energy
364   for (i = 0 ; i < ndigits ; i++) { 
365     digit = dynamic_cast<AliPHOSDigit*>( digits->At(i) ) ; 
366     digit->SetIndexInList(i) ;     
367     Float_t energy = sDigitizer->Calibrate(digit->GetAmp()) ;
368     digit->SetAmp(DigitizeEnergy(energy,digit->GetId()) ) ;
369   }
370 }
371
372 //____________________________________________________________________________
373 Int_t AliPHOSDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
374 {
375   // Returns digitized value of the energy in a cell absId
376
377   Int_t chanel ;
378   if(absId <= fEmcCrystals){ //digitize as EMC 
379     chanel = (Int_t) TMath::Ceil((energy - fADCpedestalEmc)/fADCchanelEmc) ;       
380     if(chanel > fNADCemc ) chanel =  fNADCemc ;
381   }
382   else{ //Digitize as CPV
383     chanel = (Int_t) TMath::Ceil((energy - fADCpedestalCpv)/fADCchanelCpv) ;       
384     if(chanel > fNADCcpv ) chanel =  fNADCcpv ;
385   }
386   return chanel ;
387 }
388
389 //____________________________________________________________________________
390 void AliPHOSDigitizer::Exec(Option_t *option) 
391
392   // Does the job
393
394   if (!fInit) { // to prevent overwrite existing file
395     Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
396     return ;
397   }   
398
399   if (strstr(option,"print")) {
400     Print();
401     return ; 
402   }
403   
404   if(strstr(option,"tim"))
405     gBenchmark->Start("PHOSDigitizer");
406   
407   if (fManager) 
408     fInput = fManager->GetNinputs() ;
409   
410   AliPHOSGetter * gime = AliPHOSGetter::Instance() ;
411
412   Int_t nevents = gime->MaxEvent() ;
413     
414   Int_t ievent ;
415
416   for(ievent = 0; ievent < nevents; ievent++){
417  
418     gime->Event(ievent,"S") ;
419
420     Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
421
422     WriteDigits() ;
423
424     if(strstr(option,"deb"))
425       PrintDigits(option);
426     
427     //increment the total number of Digits per run 
428     fDigitsInRun += gime->Digits()->GetEntriesFast() ;  
429  }
430   
431   if(strstr(option,"tim")){
432     gBenchmark->Stop("PHOSDigitizer");
433     TString message ; 
434     message = "  took %f seconds for Digitizing %f seconds per event\n" ; 
435     Info("Exec", message.Data(), 
436          gBenchmark->GetCpuTime("PHOSDigitizer"), 
437          gBenchmark->GetCpuTime("PHOSDigitizer")/nevents ); 
438   } 
439 }
440
441 //____________________________________________________________________________ 
442 Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks) const
443 {
444   // Returns the shortest time among all time ticks
445
446   ticks->Sort() ; //Sort in accordance with times of ticks
447   TIter it(ticks) ;
448   AliPHOSTick * ctick = (AliPHOSTick *) it.Next() ;
449   Float_t time = ctick->CrossingTime(fTimeThreshold) ;    
450
451   AliPHOSTick * t ;  
452   while((t=(AliPHOSTick*) it.Next())){
453     if(t->GetTime() < time)  //This tick starts before crossing
454       *ctick+=*t ;
455     else
456       return time ;
457
458     time = ctick->CrossingTime(fTimeThreshold) ;    
459   }
460   return time ;
461 }
462
463 //____________________________________________________________________________ 
464 Bool_t AliPHOSDigitizer::Init()
465 {
466   // Makes all memory allocations
467   fInit = kTRUE ; 
468   AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
469   if ( gime == 0 ) {
470     Fatal("Init" ,"Could not obtain the Getter object for file %s and event %s !", GetTitle(), fEventFolderName.Data()) ;  
471     return kFALSE;
472   } 
473   
474   const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
475
476   fEmcCrystals = geom->GetNModules() * geom->GetNCristalsInModule() ;
477   
478   TString opt("Digits") ; 
479   if(gime->VersionExists(opt) ) { 
480     Error( "Init", "Give a version name different from %s", fEventFolderName.Data() ) ;
481     fInit = kFALSE ; 
482   }
483
484   // Post Digitizer to the white board
485   gime->PostDigitizer(this) ;
486   
487   if (fManager) 
488     fInput = fManager->GetNinputs() ; 
489   else 
490     fInput           = 1 ;
491   
492   fInputFileNames  = new TString[fInput] ; 
493   fEventNames      = new TString[fInput] ; 
494   fInputFileNames[0] = GetTitle() ; 
495   fEventNames[0]     = fEventFolderName.Data() ; 
496   Int_t index ; 
497   for (index = 1 ; index < fInput ; index++) {
498     fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0); 
499     TString tempo = fManager->GetInputFolderName(index) ;
500     fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager 
501   }
502
503   //to prevent cleaning of this object while GetEvent is called
504   gime->PhosLoader()->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
505
506   return fInit ; 
507 }
508
509 //____________________________________________________________________________ 
510 void AliPHOSDigitizer::InitParameters()
511 {
512   // Set initial parameters for Digitizer
513
514   fPinNoise           = 0.004 ;
515   fEMCDigitThreshold  = 0.012 ;
516   fCPVNoise           = 0.01;
517   fCPVDigitThreshold  = 0.09 ;
518   fTimeResolution     = 0.5e-9 ;
519   fTimeSignalLength   = 1.0e-9 ;
520   fDigitsInRun  = 0 ; 
521   fADCchanelEmc = 0.0015;        // width of one ADC channel in GeV
522   fADCpedestalEmc = 0.005 ;      //
523   fNADCemc = (Int_t) TMath::Power(2,16) ;  // number of channels in EMC ADC
524
525   fADCchanelCpv = 0.0012 ;          // width of one ADC channel in CPV 'popugais'
526   fADCpedestalCpv = 0.012 ;         // 
527   fNADCcpv = (Int_t) TMath::Power(2,12);      // number of channels in CPV ADC
528
529   fTimeThreshold = 0.001*10000000 ; //Means 1 MeV in terms of SDigits amplitude
530     
531 }
532
533 //__________________________________________________________________
534 void AliPHOSDigitizer::MixWith(const TString alirunFileName, const TString eventFolderName)
535 {
536   // Allows to produce digits by superimposing background and signal event.
537   // It is assumed, that headers file with SIGNAL events is opened in 
538   // the constructor. 
539   // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed 
540   // Thus we avoid writing (changing) huge and expensive 
541   // backgound files: all output will be writen into SIGNAL, i.e. 
542   // opened in constructor file. 
543   //
544   // One can open as many files to mix with as one needs.
545   // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
546   // can be mixed.
547
548   if( strcmp(fEventFolderName, "") == 0 )
549     Init() ;
550
551   if(fManager){
552     Warning("MixWith", "Cannot use this method with AliRunDigitizer\n" ) ;
553     return ;
554   }
555   // looking for file which contains AliRun
556   if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
557     Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
558     return ; 
559   }
560   // looking for the file which contains SDigits
561   AliPHOSGetter * gime = AliPHOSGetter::Instance() ; 
562   TString fileName( gime->GetSDigitsFileName() ) ; 
563     if ( eventFolderName != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
564       fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
565     if ( (gSystem->AccessPathName(fileName)) ) { 
566       Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
567       return ;
568     }
569     // need to increase the arrays
570     TString tempo = fInputFileNames[fInput-1] ; 
571     delete [] fInputFileNames ; 
572     fInputFileNames = new TString[fInput+1] ; 
573     fInputFileNames[fInput-1] = tempo ; 
574  
575     tempo = fEventNames[fInput-1] ; 
576     delete [] fEventNames ; 
577     fEventNames = new TString[fInput+1] ; 
578     fEventNames[fInput-1] = tempo ; 
579
580     fInputFileNames[fInput] = alirunFileName ; 
581     fEventNames[fInput]     = eventFolderName ;
582     fInput++ ;
583 }
584
585 //__________________________________________________________________
586 void AliPHOSDigitizer::Print()const 
587 {
588   // Print Digitizer's parameters
589   Info("Print", "\n------------------- %s -------------", GetName() ) ; 
590   if( strcmp(fEventFolderName.Data(), "") != 0 ){
591     printf(" Writing Digits to branch with title  %s\n", fEventFolderName.Data()) ;
592     
593     Int_t nStreams ; 
594     if (fManager) 
595       nStreams =  GetNInputStreams() ;
596     else 
597       nStreams = fInput ; 
598     
599     Int_t index = 0 ;  
600     for (index = 0 ; index < nStreams ; index++) {  
601       TString tempo(fEventNames[index]) ; 
602       tempo += index ;
603       AliPHOSGetter * gime = AliPHOSGetter::Instance(fInputFileNames[index], tempo) ; 
604       TString fileName( gime->GetSDigitsFileName() ) ; 
605       if ( fEventNames[index] != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
606         fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index]  + ".root" ;
607       printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ; 
608     }
609     AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
610     printf("\nWriting digits to %s", gime->GetDigitsFileName().Data()) ;
611     
612     printf("\nWith following parameters:\n") ;
613     printf("  Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise ) ; 
614     printf("  Threshold  in EMC  (fEMCDigitThreshold) = %f\n", fEMCDigitThreshold ) ;  
615     printf("  Noise in CPV (fCPVNoise) = %f\n", fCPVNoise ) ; 
616     printf("  Threshold in CPV (fCPVDigitThreshold) = %f\n",fCPVDigitThreshold ) ;  
617     printf(" ---------------------------------------------------\n") ;   
618   }
619   else
620     Info("Print", "AliPHOSDigitizer not initialized" ) ;
621   
622 }
623
624 //__________________________________________________________________
625  void AliPHOSDigitizer::PrintDigits(Option_t * option)
626 {
627   // Print a table of digits
628   
629   AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
630   TClonesArray * digits = gime->Digits() ; 
631   
632   Info("PrintDigits", "%d", digits->GetEntriesFast()) ; 
633   printf("\nevent %d", gAlice->GetEvNumber()) ;
634   printf("\n       Number of entries in Digits list %d", digits->GetEntriesFast() )  ;  
635
636  
637   if(strstr(option,"all")||strstr(option,"EMC")){  
638     //loop over digits
639     AliPHOSDigit * digit;
640     printf("\nEMC digits (with primaries):\n")  ;
641     printf("\n   Id  Amplitude    Time          Index Nprim: Primaries list \n") ;    
642     Int_t maxEmc = gime->PHOSGeometry()->GetNModules()*gime->PHOSGeometry()->GetNCristalsInModule() ;
643     Int_t index ;
644     for (index = 0 ; (index < digits->GetEntriesFast()) && 
645            (dynamic_cast<AliPHOSDigit *>(digits->At(index))->GetId() <= maxEmc) ; index++) {
646       digit = (AliPHOSDigit * )  digits->At(index) ;
647       if(digit->GetNprimary() == 0) 
648         continue;
649       printf("%6d  %8d    %6.5e %4d      %2d :",
650               digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;  
651       Int_t iprimary;
652       for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
653         printf("%d ",digit->GetPrimary(iprimary+1) ) ; 
654       }    
655       printf("\n") ;
656     }
657   }
658   
659   if(strstr(option,"all")||strstr(option,"CPV")){
660     
661     //loop over CPV digits
662     AliPHOSDigit * digit;
663     printf("\nCPV digits (with primaries):\n")  ;
664     printf("\n   Id  Amplitude    Time          Index Nprim: Primaries list \n") ;    
665     Int_t maxEmc = gime->PHOSGeometry()->GetNModules()*gime->PHOSGeometry()->GetNCristalsInModule() ;
666     Int_t index ;
667     for (index = 0 ; index < digits->GetEntriesFast(); index++) {
668       digit = (AliPHOSDigit * )  digits->At(index) ;
669       if(digit->GetId() > maxEmc){
670         printf("%6d  %8d    %4d      %2d :",
671                 digit->GetId(), digit->GetAmp(), digit->GetIndexInList(), digit->GetNprimary()) ;  
672         Int_t iprimary;
673         for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
674           printf("%d ",digit->GetPrimary(iprimary+1) ) ; 
675         }    
676         printf("\n") ;
677       }
678     }
679   }
680
681 }
682
683 //__________________________________________________________________
684 Float_t AliPHOSDigitizer::TimeOfNoise(void) const
685 {  // Calculates the time signal generated by noise
686   //to be rewritten, now returns just big number
687   return 1. ;
688
689 }
690
691 //__________________________________________________________________
692 void AliPHOSDigitizer::Unload() 
693 {  
694   
695   Int_t i ; 
696   for(i = 1 ; i < fInput ; i++){
697     TString tempo(fEventNames[i]) ; 
698     tempo += i ;
699     AliPHOSGetter * gime = AliPHOSGetter::Instance(fInputFileNames[i], tempo) ; 
700     gime->PhosLoader()->UnloadSDigits() ; 
701   }
702   
703   AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
704   gime->PhosLoader()->UnloadDigits() ; 
705 }
706
707 //____________________________________________________________________________
708 void AliPHOSDigitizer::WriteDigits()
709 {
710
711   // Makes TreeD in the output file. 
712   // Check if branch already exists: 
713   //   if yes, exit without writing: ROOT TTree does not support overwriting/updating of 
714   //      already existing branches. 
715   //   else creates branch with Digits, named "PHOS", title "...",
716   //      and branch "AliPHOSDigitizer", with the same title to keep all the parameters
717   //      and names of files, from which digits are made.
718
719   AliPHOSGetter * gime = AliPHOSGetter::Instance(GetTitle(), fEventFolderName) ; 
720   const TClonesArray * digits = gime->Digits() ; 
721   TTree * treeD = gime->TreeD();
722
723   // -- create Digits branch
724   Int_t bufferSize = 32000 ;    
725   TBranch * digitsBranch = treeD->Branch("PHOS",&digits,bufferSize);
726   digitsBranch->SetTitle(fEventFolderName);
727   digitsBranch->Fill() ;
728   
729   gime->WriteDigits("OVERWRITE");
730   gime->WriteDigitizer("OVERWRITE");
731
732   Unload() ; 
733
734 }