Coverity fix.
[u/mrichter/AliRoot.git] / PHOS / AliPHOSDigitizer.cxx
CommitLineData
990119d6 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
702ab87e 18/* History of cvs commits:
19 *
a28333c5 20 * $Log: AliPHOSDigitizer.cxx,v $
21 * Revision 1.104 2007/12/18 09:08:18 hristov
22 * Splitting of the QA maker into simulation and reconstruction dependent parts (Yves)
23 *
04236e67 24 * Revision 1.103 2007/11/07 11:25:06 schutz
25 * Comment out the QA checking before starting digitization
26 *
18c3b8c2 27 * Revision 1.102 2007/10/19 18:04:29 schutz
28 * The standalone QA data maker is called from AliSimulation and AliReconstruction outside the event loop; i.e. re-reading the data. The QA data making in the event loop has been commented out.
29 *
c65c502a 30 * Revision 1.101 2007/10/14 21:08:10 schutz
31 * Introduced the checking of QA results from previous step before entering the event loop
32 *
8661738e 33 * Revision 1.100 2007/10/10 09:05:10 schutz
34 * Changing name QualAss to QA
35 *
b8274834 36 * Revision 1.99 2007/09/30 17:08:20 schutz
37 * Introducing the notion of QA data acquisition cycle (needed by online)
38 *
5b188f2f 39 * Revision 1.98 2007/09/26 14:22:17 cvetan
40 * Important changes to the reconstructor classes. Complete elimination of the run-loaders, which are now steered only from AliReconstruction. Removal of the corresponding Reconstruct() and FillESD() methods.
41 *
d76c31f4 42 * Revision 1.97 2007/08/07 14:12:03 kharlov
43 * Quality assurance added (Yves Schutz)
44 *
ddd1a39c 45 * Revision 1.96 2007/04/28 10:43:36 policheh
46 * Dead channels simulation: digit energy sets to 0.
47 *
1c6a163f 48 * Revision 1.95 2007/04/10 07:20:52 kharlov
49 * Decalibration should use the same CDB as calibration in AliPHOSClusterizerv1
50 *
1a197b77 51 * Revision 1.94 2007/02/01 10:34:47 hristov
52 * Removing warnings on Solaris x86
53 *
ad4aeaf4 54 * Revision 1.93 2006/10/17 13:17:01 kharlov
55 * Replace AliInfo by AliDebug
56 *
d6e8d7d3 57 * Revision 1.92 2006/08/28 10:01:56 kharlov
58 * Effective C++ warnings fixed (Timur Pocheptsov)
59 *
3663622c 60 * Revision 1.91 2006/04/29 20:25:30 hristov
61 * Decalibration is implemented (Yu.Kharlov)
62 *
877695e7 63 * Revision 1.90 2006/04/22 10:30:17 hristov
64 * Add fEnergy to AliPHOSDigit and operate with EMC amplitude in energy units (Yu.Kharlov)
65 *
27a73a5d 66 * Revision 1.89 2006/04/11 15:22:59 hristov
67 * run number in query set to -1: forces AliCDBManager to use its run number (A.Colla)
68 *
28871337 69 * Revision 1.88 2006/03/13 14:05:43 kharlov
70 * Calibration objects for EMC and CPV
71 *
fc6706cb 72 * Revision 1.87 2005/08/24 15:33:49 kharlov
73 * Calibration data for raw digits
74 *
a8ec0771 75 * Revision 1.86 2005/07/12 20:07:35 hristov
76 * Changes needed to run simulation and reconstrruction in the same AliRoot session
77 *
7c193632 78 * Revision 1.85 2005/05/28 14:19:04 schutz
79 * Compilation warnings fixed by T.P.
80 *
702ab87e 81 */
88cb7938 82
990119d6 83//_________________________________________________________________________
990119d6 84//*-- Author : Dmitri Peressounko (SUBATECH & Kurchatov Institute)
85//////////////////////////////////////////////////////////////////////////////
f21fc003 86// This class performs digitization of Summable digits (in the PHOS case it is just
a4e98857 87// the sum of contributions from all primary particles into a given cell).
990119d6 88// In addition it performs mixing of summable digits from different events.
f21fc003 89// The name of the class is also the title of the branch that will contain
7b7c1533 90// the created SDigits
f21fc003 91// The title of the class is the name of the file that contains the hits from
7b7c1533 92// which the SDigits are created
bca3b32a 93//
94// For each event two branches are created in TreeD:
95// "PHOS" - list of digits
96// "AliPHOSDigitizer" - AliPHOSDigitizer with all parameters used in digitization
97//
a4e98857 98// Note, that one can set a title for new digits branch, and repeat digitization with
bca3b32a 99// another set of parameters.
100//
a4e98857 101// Use case:
990119d6 102// root[0] AliPHOSDigitizer * d = new AliPHOSDigitizer() ;
f21fc003 103// root[1] d->Digitize()
990119d6 104// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
105// //Digitizes SDigitis in all events found in file galice.root
bca3b32a 106//
8cb3533f 107// root[2] AliPHOSDigitizer * d1 = new AliPHOSDigitizer("galice1.root") ;
108// // Will read sdigits from galice1.root
109// root[3] d1->MixWith("galice2.root")
990119d6 110// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
a4e98857 111// // Reads another set of sdigits from galice2.root
8cb3533f 112// root[3] d1->MixWith("galice3.root")
a4e98857 113// // Reads another set of sdigits from galice3.root
f21fc003 114// root[4] d->Digitize("deb timing")
8cb3533f 115// // Reads SDigits from files galice1.root, galice2.root ....
116// // mixes them and stores produced Digits in file galice1.root
117// // deb - prints number of produced digits
118// // deb all - prints list of produced digits
119// // timing - prints time used for digitization
990119d6 120//
990119d6 121
122// --- ROOT system ---
990119d6 123#include "TTree.h"
124#include "TSystem.h"
8cb3533f 125#include "TBenchmark.h"
e957fea8 126#include "TRandom.h"
f898e0f3 127#include "TMath.h"
ba54256b 128
990119d6 129// --- Standard library ---
130
131// --- AliRoot header files ---
e250de8f 132#include <TGeoManager.h>
351dd634 133#include "AliLog.h"
f21fc003 134#include "AliDigitizationInput.h"
990119d6 135#include "AliPHOSDigit.h"
990119d6 136#include "AliPHOSDigitizer.h"
8cb3533f 137#include "AliPHOSGeometry.h"
7437a0f7 138#include "AliPHOSTick.h"
f898e0f3 139#include "AliPHOSSimParam.h"
140#include "AliPHOSCalibData.h"
141#include "AliRunLoader.h"
142#include "AliPHOSLoader.h"
54ac223e 143#include "AliPHOSPulseGenerator.h"
990119d6 144
145ClassImp(AliPHOSDigitizer)
146
147
148//____________________________________________________________________________
3663622c 149AliPHOSDigitizer::AliPHOSDigitizer() :
150 AliDigitizer("",""),
151 fDefaultInit(kTRUE),
152 fDigitsInRun(0),
153 fInit(kFALSE),
154 fInput(0),
155 fInputFileNames(0x0),
156 fEventNames(0x0),
157 fEmcCrystals(0),
3663622c 158 fEventFolderName(""),
159 fFirstEvent(0),
ddd1a39c 160 fLastEvent(0),
f898e0f3 161 fcdb(0x0),
54ac223e 162 fEventCounter(0),
163 fPulse(0),
164 fADCValuesLG(0),
165 fADCValuesHG(0)
990119d6 166{
167 // ctor
8d0f3f77 168 InitParameters() ;
f21fc003 169 fDigInput = 0 ; // We work in the standalong mode
88cb7938 170}
3f81a70b 171
172//____________________________________________________________________________
e191bb57 173AliPHOSDigitizer::AliPHOSDigitizer(TString alirunFileName,
174 TString eventFolderName):
f21fc003 175 AliDigitizer("PHOSDigitizer", alirunFileName),
3663622c 176 fDefaultInit(kFALSE),
177 fDigitsInRun(0),
178 fInit(kFALSE),
179 fInput(0),
180 fInputFileNames(0x0),
181 fEventNames(0x0),
182 fEmcCrystals(0),
3663622c 183 fEventFolderName(eventFolderName),
184 fFirstEvent(0),
ddd1a39c 185 fLastEvent(0),
f898e0f3 186 fcdb(0x0),
54ac223e 187 fEventCounter(0),
188 fPulse(0),
189 fADCValuesLG(0),
190 fADCValuesHG(0)
3f81a70b 191{
192 // ctor
8d0f3f77 193 InitParameters() ;
3f81a70b 194 Init() ;
92f521a9 195 fDefaultInit = kFALSE ;
f21fc003 196 fDigInput = 0 ; // We work in the standalone mode
f898e0f3 197 fcdb = new AliPHOSCalibData(-1);
88cb7938 198}
199
200//____________________________________________________________________________
3663622c 201AliPHOSDigitizer::AliPHOSDigitizer(const AliPHOSDigitizer & d) :
202 AliDigitizer(d),
203 fDefaultInit(d.fDefaultInit),
204 fDigitsInRun(d.fDigitsInRun),
205 fInit(d.fInit),
206 fInput(d.fInput),
4c253378 207 fInputFileNames(0x0),
208 fEventNames(0x0),
3663622c 209 fEmcCrystals(d.fEmcCrystals),
3663622c 210 fEventFolderName(d.fEventFolderName),
211 fFirstEvent(d.fFirstEvent),
ddd1a39c 212 fLastEvent(d.fLastEvent),
4c253378 213 fcdb (new AliPHOSCalibData(-1)),
54ac223e 214 fEventCounter(0),
4c253378 215 fPulse(new AliPHOSPulseGenerator),
54ac223e 216 fADCValuesLG(0),
217 fADCValuesHG(0)
88cb7938 218{
219 // copyy ctor
88cb7938 220 SetName(d.GetName()) ;
221 SetTitle(d.GetTitle()) ;
4c253378 222 for (Int_t iInput=0; iInput<fInput; iInput++) {
223 fInputFileNames[iInput] = d.fInputFileNames[iInput];
224 fEventNames[iInput] = d.fEventNames[iInput];
225 }
da105eb9 226 fADCValuesLG = new Int_t[fPulse->GetRawFormatTimeBins()];
227 fADCValuesHG = new Int_t[fPulse->GetRawFormatTimeBins()];
990119d6 228}
229
990119d6 230//____________________________________________________________________________
f21fc003 231AliPHOSDigitizer::AliPHOSDigitizer(AliDigitizationInput * rd) :
232 AliDigitizer(rd,"PHOSDigitizer"),
3663622c 233 fDefaultInit(kFALSE),
234 fDigitsInRun(0),
235 fInit(kFALSE),
236 fInput(0),
237 fInputFileNames(0x0),
238 fEventNames(0x0),
239 fEmcCrystals(0),
f21fc003 240 fEventFolderName(fDigInput->GetInputFolderName(0)),
3663622c 241 fFirstEvent(0),
ddd1a39c 242 fLastEvent(0),
f898e0f3 243 fcdb (0x0),
54ac223e 244 fEventCounter(0),
245 fPulse(0),
246 fADCValuesLG(0),
247 fADCValuesHG(0)
ddd1a39c 248
990119d6 249{
45fa49ca 250 // ctor Init() is called by RunDigitizer
f21fc003 251 fDigInput = rd ;
252 SetTitle(static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetFileName(0));
b22e4735 253 InitParameters() ;
fbf811ec 254 fDefaultInit = kFALSE ;
f898e0f3 255 fcdb = new AliPHOSCalibData(-1);
990119d6 256}
257
258//____________________________________________________________________________
259 AliPHOSDigitizer::~AliPHOSDigitizer()
260{
f21fc003 261 // dtor
88cb7938 262 delete [] fInputFileNames ;
263 delete [] fEventNames ;
ddd1a39c 264
54ac223e 265 delete fPulse;
266 delete [] fADCValuesLG;
267 delete [] fADCValuesHG;
268
f898e0f3 269 if(fcdb){ delete fcdb ; fcdb=0;}
ddd1a39c 270
990119d6 271}
272
273//____________________________________________________________________________
fc7e2f43 274void AliPHOSDigitizer::Digitize(Int_t event)
a4e98857 275{
276
277 // Makes the digitization of the collected summable digits.
278 // It first creates the array of all PHOS modules
dc986a1d 279 // filled with noise (different for EMC, and CPV) and
a4e98857 280 // then adds contributions from SDigits.
281 // This design avoids scanning over the list of digits to add
282 // contribution to new SDigits only.
990119d6 283
f898e0f3 284 Bool_t toMakeNoise = kTRUE ; //Do not create noisy digits if merge with real data
285
286 //First stream
287 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 288 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 289
290 Int_t readEvent = event ;
f21fc003 291 if (fDigInput)
292 readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetCurrentEventNumber() ;
d6e8d7d3 293 AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
f898e0f3 294 readEvent, GetTitle(), fEventFolderName.Data())) ;
295 rl->GetEvent(readEvent) ;
296 phosLoader->CleanSDigits() ;
297 phosLoader->LoadSDigits("READ") ;
298
299 //Prepare Output
300 TClonesArray * digits = phosLoader->Digits() ;
301 if( !digits ) {
302 phosLoader->MakeDigitsArray() ;
303 digits = phosLoader->Digits() ;
304 }
305
7b7c1533 306 digits->Clear() ;
990119d6 307
f898e0f3 308 //
309 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
990119d6 310 //Making digits with noise, first EMC
e250de8f 311 //Check which PHOS modules are present
312 Bool_t isPresent[5] ;
313 TString volpath ;
314 Int_t nmod=0 ;
315 for(Int_t i=0; i<5; i++){
316 volpath = "/ALIC_1/PHOS_";
317 volpath += i+1;
318 if (gGeoManager->CheckPath(volpath.Data())) {
319 isPresent[i]=1 ;
320 nmod++ ;
321 }
322 else{
323 isPresent[i]=0 ;
324 }
325 }
326
327 Int_t nEMC = nmod*geom->GetNPhi()*geom->GetNZ();
990119d6 328
329 Int_t nCPV ;
990119d6 330 Int_t absID ;
990119d6 331
e250de8f 332 //check if CPV exists
333 Bool_t isCPVpresent=0 ;
334 for(Int_t i=1; i<=5 && !isCPVpresent; i++){
335 volpath = "/ALIC_1/PHOS_";
336 volpath += i;
337 volpath += "/PCPV_1";
338 if (gGeoManager->CheckPath(volpath.Data()))
339 isCPVpresent=1 ;
340 }
88cb7938 341
e250de8f 342 if(isCPVpresent){
343 nCPV = nEMC + geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() * nmod ;
344 }
345 else{
346 nCPV = nEMC ;
347 }
348
9688c1dd 349 digits->Expand(nCPV) ;
8cb3533f 350
88cb7938 351 //take all the inputs to add together and load the SDigits
352 TObjArray * sdigArray = new TObjArray(fInput) ;
f898e0f3 353 sdigArray->AddAt(phosLoader->SDigits(), 0) ;
354
355 for(Int_t i = 1 ; i < fInput ; i++){
88cb7938 356 TString tempo(fEventNames[i]) ;
357 tempo += i ;
f898e0f3 358 AliRunLoader* rl2 = AliRunLoader::GetRunLoader(tempo) ;
359 if(!rl2){
360 rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
361 if (!rl2) {
362 Fatal("AliPHOSDigitizer", "Could not find the Run Loader for %s - %s",fInputFileNames[i].Data(), tempo.Data()) ;
363 return ;
364 }
365 rl2->LoadHeader();
366 }
97e75f77 367 AliPHOSLoader * phosLoader2 = static_cast<AliPHOSLoader*>(rl2->GetLoader("PHOSLoader"));
f898e0f3 368
f21fc003 369 if(fDigInput){
370 readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(i))->GetCurrentEventNumber() ;
f898e0f3 371 }
372 TClonesArray * digs ;
373 if(AliPHOSSimParam::GetInstance()->IsStreamDigits(i)){ //This is Digits Stream
374 AliInfo(Form("Adding event %d from input stream %d %s %s",
375 readEvent, i, fInputFileNames[i].Data(), tempo.Data())) ;
376 rl2->GetEvent(readEvent) ;
377 phosLoader2->CleanDigits() ;
378 phosLoader2->LoadDigits("READ") ;
379 digs = phosLoader2->Digits() ;
380 toMakeNoise=0 ; //Do not add noise, it is already in stream
381 }
382 else{
383 AliInfo(Form("Adding event %d (SDigits) from input stream %d %s %s",
384 readEvent, i, fInputFileNames[i].Data(), tempo.Data())) ;
385 rl2->GetEvent(readEvent) ;
386 phosLoader2->CleanSDigits() ;
387 phosLoader2->LoadSDigits("READ") ;
388 digs = phosLoader2->SDigits() ;
389 }
390 sdigArray->AddAt(digs, i) ;
38bb0fd5 391 }
9688c1dd 392
27a73a5d 393 //Find the first crystal with signal
9688c1dd 394 Int_t nextSig = 200000 ;
88cb7938 395 TClonesArray * sdigits ;
f898e0f3 396 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 397 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
a6eedfad 398 if ( !sdigits->GetEntriesFast() )
7a9d98f9 399 continue ;
97e75f77 400 Int_t curNext = static_cast<AliPHOSDigit *>(sdigits->At(0))->GetId() ;
88cb7938 401 if(curNext < nextSig)
402 nextSig = curNext ;
9688c1dd 403 }
88cb7938 404
405 TArrayI index(fInput) ;
9688c1dd 406 index.Reset() ; //Set all indexes to zero
88cb7938 407
9688c1dd 408 AliPHOSDigit * digit ;
409 AliPHOSDigit * curSDigit ;
88cb7938 410
f898e0f3 411// TClonesArray * ticks = new TClonesArray("AliPHOSTick",1000) ;
88cb7938 412
9688c1dd 413 //Put Noise contribution
f898e0f3 414 Double_t apdNoise = 0. ;
415 if(toMakeNoise)
416 apdNoise = AliPHOSSimParam::GetInstance()->GetAPDNoise() ;
417
e250de8f 418 Int_t emcpermod=geom->GetNPhi()*geom->GetNZ();
419 Int_t idigit= 0;
420 for(Int_t imod=0; imod<5; imod++){
421 if(!isPresent[imod])
422 continue ;
423 Int_t firstAbsId=imod*emcpermod+1 ;
424 Int_t lastAbsId =(imod+1)*emcpermod ;
425 for(absID = firstAbsId ; absID <= lastAbsId ; absID++){
426 Float_t noise = gRandom->Gaus(0.,apdNoise) ;
427 new((*digits)[idigit]) AliPHOSDigit( -1, absID, noise, TimeOfNoise() ) ;
428 //look if we have to add signal?
97e75f77 429 digit = static_cast<AliPHOSDigit *>(digits->At(idigit)) ;
e250de8f 430 idigit++ ;
88cb7938 431
e250de8f 432 if(absID==nextSig){
9688c1dd 433 //Add SDigits from all inputs
f898e0f3 434// ticks->Clear() ;
435// Int_t contrib = 0 ;
436
437//New Timing model is necessary
438// Float_t a = digit->GetEnergy() ;
439// Float_t b = TMath::Abs( a / fTimeSignalLength) ;
440// //Mark the beginning of the signal
441// new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime(),0, b);
442// //Mark the end of the signal
443// new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime()+fTimeSignalLength, -a, -b);
444
445// Calculate time as time of the largest digit
e250de8f 446 Float_t time = digit->GetTime() ;
447 Float_t eTime= digit->GetEnergy() ;
88cb7938 448
e250de8f 449 //loop over inputs
450 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 451 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] ){
452 curSDigit = static_cast<AliPHOSDigit*>(static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
737c795f 453 if(AliPHOSSimParam::GetInstance()->IsStreamDigits(i)){ //This is Digits Stream
454 curSDigit->SetEnergy(Calibrate(curSDigit->GetEnergy(),curSDigit->GetId())) ;
6f47f50d 455 curSDigit->SetTime(CalibrateT(curSDigit->GetTime(),curSDigit->GetId())) ;
737c795f 456 }
457 }
9688c1dd 458 else
e250de8f 459 curSDigit = 0 ;
460 //May be several digits will contribute from the same input
461 while(curSDigit && curSDigit->GetId() == absID){
462 //Shift primary to separate primaries belonging different inputs
463 Int_t primaryoffset ;
f21fc003 464 if(fDigInput)
465 primaryoffset = fDigInput->GetMask(i) ;
e250de8f 466 else
467 primaryoffset = 10000000*i ;
468 curSDigit->ShiftPrimary(primaryoffset) ;
7437a0f7 469
f898e0f3 470//New Timing model is necessary
471// a = curSDigit->GetEnergy() ;
472// b = a /fTimeSignalLength ;
473// new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime(),0, b);
474// new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
475 if(curSDigit->GetEnergy()>eTime){
476 eTime=curSDigit->GetEnergy() ;
477 time=curSDigit->GetTime() ;
478 }
e250de8f 479 *digit += *curSDigit ; //add energies
480
481 index[i]++ ;
97e75f77 482 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
483 curSDigit = static_cast<AliPHOSDigit*>(static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
e250de8f 484 else
485 curSDigit = 0 ;
486 }
487 }
88cb7938 488
e250de8f 489 //calculate and set time
f898e0f3 490//New Timing model is necessary
491// Float_t time = FrontEdgeTime(ticks) ;
e250de8f 492 digit->SetTime(time) ;
88cb7938 493
e250de8f 494 //Find next signal module
495 nextSig = 200000 ;
496 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 497 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
e250de8f 498 Int_t curNext = nextSig ;
499 if(sdigits->GetEntriesFast() > index[i] ){
97e75f77 500 curNext = static_cast<AliPHOSDigit *>(sdigits->At(index[i]))->GetId() ;
e250de8f 501 }
502 if(curNext < nextSig) nextSig = curNext ;
503 }
7b7c1533 504 }
505 }
990119d6 506 }
f898e0f3 507
dde7e19f 508
509 //Apply non-linearity
510 if(AliPHOSSimParam::GetInstance()->IsCellNonlinearityOn()){ //Apply non-lineairyt on cell level
511 const Double_t aNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyA() ;
512 const Double_t bNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyB() ;
9d68672f 513 const Double_t cNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyC() ;
dde7e19f 514 for(Int_t i = 0 ; i < nEMC ; i++){
515 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
516 Double_t e= digit->GetEnergy() ;
517 // version(1) digit->SetEnergy(e*(1+a*TMath::Exp(-e/b))) ;
9d68672f 518 digit->SetEnergy(e*cNL*(1.+aNL*TMath::Exp(-e*e/2./bNL/bNL))) ; //Better agreement with data...
dde7e19f 519 }
520 }
521
522
f898e0f3 523 //distretize energy if necessary
524 if(AliPHOSSimParam::GetInstance()->IsEDigitizationOn()){
525 Float_t adcW=AliPHOSSimParam::GetInstance()->GetADCchannelW() ;
526 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 527 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
f898e0f3 528 digit->SetEnergy(adcW*ceil(digit->GetEnergy()/adcW)) ;
529 }
530 }
dde7e19f 531
737c795f 532 //Apply decalibration if necessary
533 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 534 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
737c795f 535 Decalibrate(digit) ;
167d2780 536 }
3f81a70b 537
f898e0f3 538// ticks->Delete() ;
539// delete ticks ;
88cb7938 540
9688c1dd 541 //Now CPV digits (different noise and no timing)
e250de8f 542 Int_t cpvpermod = geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() ;
543 Int_t nEMCtotal=emcpermod*5 ;
f898e0f3 544 Float_t cpvNoise = AliPHOSSimParam::GetInstance()->GetCPVNoise() ;
e250de8f 545 if(isCPVpresent){ //CPV is present in current geometry
546 for(Int_t imod=0; imod<5; imod++){ //module is present in current geometry
547 if(!isPresent[imod])
548 continue ;
549 Int_t firstAbsId=nEMCtotal+imod*cpvpermod+1 ;
550 Int_t lastAbsId =nEMCtotal+(imod+1)*cpvpermod ;
551 for(absID = firstAbsId; absID <= lastAbsId; absID++){
552 Float_t noise = gRandom->Gaus(0., cpvNoise) ;
553 new((*digits)[idigit]) AliPHOSDigit( -1,absID,noise, TimeOfNoise() ) ;
554 idigit++ ;
555 //look if we have to add signal?
556 if(absID==nextSig){
97e75f77 557 digit = static_cast<AliPHOSDigit *>(digits->At(idigit-1)) ;
e250de8f 558 //Add SDigits from all inputs
559 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 560 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
561 curSDigit = static_cast<AliPHOSDigit*>( static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
e250de8f 562 else
563 curSDigit = 0 ;
564
565 //May be several digits will contribute from the same input
566 while(curSDigit && curSDigit->GetId() == absID){
567 //Shift primary to separate primaries belonging different inputs
568 Int_t primaryoffset ;
f21fc003 569 if(fDigInput)
570 primaryoffset = fDigInput->GetMask(i) ;
e250de8f 571 else
572 primaryoffset = 10000000*i ;
573 curSDigit->ShiftPrimary(primaryoffset) ;
574
575 //add energies
576 *digit += *curSDigit ;
577 index[i]++ ;
97e75f77 578 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
579 curSDigit = static_cast<AliPHOSDigit*>( static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i]) ) ;
e250de8f 580 else
581 curSDigit = 0 ;
582 }
583 }
a6eedfad 584
e250de8f 585 //Find next signal module
586 nextSig = 200000 ;
587 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 588 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
e250de8f 589 Int_t curNext = nextSig ;
590 if(sdigits->GetEntriesFast() > index[i] )
97e75f77 591 curNext = static_cast<AliPHOSDigit *>( sdigits->At(index[i]) )->GetId() ;
e250de8f 592 if(curNext < nextSig) nextSig = curNext ;
593 }
9688c1dd 594
e250de8f 595 }
596 }
9688c1dd 597 }
598 }
88cb7938 599
600 delete sdigArray ; //We should not delete its contents
9688c1dd 601
1dfe0f3c 602 Int_t relId[4];
603
604 //set amplitudes in bad channels to zero
f898e0f3 605
65fd5dc1 606 for(Int_t i = 0 ; i <digits->GetEntriesFast(); i++){
97e75f77 607 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
f898e0f3 608 geom->AbsToRelNumbering(digit->GetId(),relId);
1dfe0f3c 609 if(relId[1] == 0) // Emc
f898e0f3 610 if(fcdb->IsBadChannelEmc(relId[0],relId[3],relId[2])) digit->SetEnergy(0.);
1dfe0f3c 611 }
612
990119d6 613 //remove digits below thresholds
f898e0f3 614 Float_t emcThreshold = AliPHOSSimParam::GetInstance()->GetEmcDigitsThreshold() ;
615 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 616 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
a28333c5 617
f898e0f3 618 if(digit->GetEnergy() < emcThreshold){
a6eedfad 619 digits->RemoveAt(i) ;
f898e0f3 620 continue ;
621 }
6f47f50d 622
54ac223e 623 geom->AbsToRelNumbering(digit->GetId(),relId);
624
dde7e19f 625// digit->SetEnergy(TMath::Ceil(digit->GetEnergy())-0.9999) ;
6f47f50d 626
f898e0f3 627 Float_t tres = TimeResolution(digit->GetEnergy()) ;
628 digit->SetTime(gRandom->Gaus(digit->GetTime(), tres) ) ;
54ac223e 629
630 fPulse->Reset();
631 fPulse->SetAmplitude(digit->GetEnergy()/
632 fcdb->GetADCchannelEmc(relId[0],relId[3],relId[2]));
633 fPulse->SetTZero(digit->GetTimeR());
634 fPulse->MakeSamples();
635 fPulse->GetSamples(fADCValuesHG, fADCValuesLG) ;
636 Int_t nSamples = fPulse->GetRawFormatTimeBins();
637 digit->SetALTROSamplesHG(nSamples,fADCValuesHG);
638 digit->SetALTROSamplesLG(nSamples,fADCValuesLG);
aaf8a71c 639 }
640
f898e0f3 641 Float_t cpvDigitThreshold = AliPHOSSimParam::GetInstance()->GetCpvDigitsThreshold() ;
642 for(Int_t i = nEMC; i < nCPV ; i++){
97e75f77 643 if( static_cast<AliPHOSDigit*>(digits->At(i))->GetEnergy() < cpvDigitThreshold )
a6eedfad 644 digits->RemoveAt(i) ;
f898e0f3 645 }
9688c1dd 646
7b7c1533 647 digits->Compress() ;
7b7c1533 648 Int_t ndigits = digits->GetEntriesFast() ;
a91822a8 649
3758d9fc 650 //Set indexes in list of digits and make true digitization of the energy
f898e0f3 651 for (Int_t i = 0 ; i < ndigits ; i++) {
97e75f77 652 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
990119d6 653 digit->SetIndexInList(i) ;
27a73a5d 654 if(digit->GetId() > fEmcCrystals){ //digitize CPV only
877695e7 655 digit->SetAmp(DigitizeCPV(digit->GetEnergy(),digit->GetId()) ) ;
27a73a5d 656 }
990119d6 657 }
f898e0f3 658
7b7c1533 659}
737c795f 660//____________________________________________________________________________
661Float_t AliPHOSDigitizer::Calibrate(Float_t amp,Int_t absId){
662 //Apply calibration
663 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
548f0134 664
737c795f 665 //Determine rel.position of the cell absolute ID
666 Int_t relId[4];
667 geom->AbsToRelNumbering(absId,relId);
668 Int_t module=relId[0];
669 Int_t row =relId[2];
670 Int_t column=relId[3];
671 if(relId[1]==0){ //This Is EMC
672 Float_t calibration = fcdb->GetADCchannelEmc(module,column,row);
673 return amp*calibration ;
674 }
675 return 0 ;
676}
3758d9fc 677//____________________________________________________________________________
737c795f 678void AliPHOSDigitizer::Decalibrate(AliPHOSDigit *digit)
3758d9fc 679{
877695e7 680 // Decalibrate EMC digit, i.e. change its energy by a factor read from CDB
681
f898e0f3 682 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
877695e7 683
684 //Determine rel.position of the cell absolute ID
685 Int_t relId[4];
f898e0f3 686 geom->AbsToRelNumbering(digit->GetId(),relId);
877695e7 687 Int_t module=relId[0];
688 Int_t row =relId[2];
689 Int_t column=relId[3];
737c795f 690 if(relId[1]==0){ //This Is EMC
b30d19db 691 Float_t decalib = fcdb->GetADCchannelEmcDecalib(module,column,row); // O(1)
692 Float_t calibration = fcdb->GetADCchannelEmc(module,column,row)*decalib;
737c795f 693 Float_t energy = digit->GetEnergy()/calibration;
694 digit->SetEnergy(energy); //Now digit measures E in ADC counts
6f47f50d 695 Float_t time = digit->GetTime() ;
696 time-=fcdb->GetTimeShiftEmc(module,column,row);
697 digit->SetTime(time) ;
737c795f 698 }
877695e7 699}
700//____________________________________________________________________________
6f47f50d 701Float_t AliPHOSDigitizer::CalibrateT(Float_t time,Int_t absId){
702 //Apply time calibration
703 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
704
705 //Determine rel.position of the cell absolute ID
706 Int_t relId[4];
707 geom->AbsToRelNumbering(absId,relId);
708 Int_t module=relId[0];
709 Int_t row =relId[2];
710 Int_t column=relId[3];
711 time += fcdb->GetTimeShiftEmc(module,column,row);
712 return time ;
713}
714//____________________________________________________________________________
877695e7 715Int_t AliPHOSDigitizer::DigitizeCPV(Float_t charge, Int_t absId)
716{
717 // Returns digitized value of the CPV charge in a pad absId
0bc3b8ed 718
f898e0f3 719 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
fc6706cb 720
a8ec0771 721 //Determine rel.position of the cell absId
722 Int_t relId[4];
f898e0f3 723 geom->AbsToRelNumbering(absId,relId);
a8ec0771 724 Int_t module=relId[0];
27a73a5d 725 Int_t row =relId[2];
a8ec0771 726 Int_t column=relId[3];
727
877695e7 728 Int_t channel = 0;
a8ec0771 729
877695e7 730 if(absId > fEmcCrystals){ //digitize CPV only
a8ec0771 731
732 //reading calibration data for cell absId.
f898e0f3 733 Float_t adcPedestalCpv = fcdb->GetADCpedestalCpv(module,column,row);
734 Float_t adcChanelCpv = fcdb->GetADCchannelCpv( module,column,row);
a8ec0771 735
f898e0f3 736 channel = (Int_t) TMath::Ceil((charge - adcPedestalCpv)/adcChanelCpv) ;
737 Int_t nMax = AliPHOSSimParam::GetInstance()->GetNADCcpv() ;
738 if(channel > nMax ) channel = nMax ;
3758d9fc 739 }
877695e7 740 return channel ;
3758d9fc 741}
548f0134 742
7b7c1533 743//____________________________________________________________________________
f21fc003 744void AliPHOSDigitizer::Digitize(Option_t *option)
7b7c1533 745{
212d1c0f 746 // Steering method to process digitization for events
747 // in the range from fFirstEvent to fLastEvent.
748 // This range is optionally set by SetEventRange().
45fa49ca 749 // if fLastEvent=-1, then process events until the end.
750 // by default fLastEvent = fFirstEvent (process only one event)
88cb7938 751
752 if (!fInit) { // to prevent overwrite existing file
351dd634 753 AliError(Form("Give a version name different from %s",
754 fEventFolderName.Data() )) ;
88cb7938 755 return ;
756 }
990119d6 757
7b7c1533 758 if (strstr(option,"print")) {
88cb7938 759 Print();
7b7c1533 760 return ;
8cb3533f 761 }
990119d6 762
8661738e 763 if(strstr(option,"tim"))
764 gBenchmark->Start("PHOSDigitizer");
3f81a70b 765
f898e0f3 766 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 767 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
5b4d2c50 768
212d1c0f 769 if (fLastEvent == -1)
f898e0f3 770 fLastEvent = rl->GetNumberOfEvents() - 1 ;
f21fc003 771 else if (fDigInput)
396a348e 772 fLastEvent = fFirstEvent ;
45fa49ca 773
212d1c0f 774 Int_t nEvents = fLastEvent - fFirstEvent + 1;
775
7b7c1533 776 Int_t ievent ;
88cb7938 777
212d1c0f 778 for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
ddd1a39c 779 fEventCounter++ ;
b22e4735 780
7b7c1533 781 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
88cb7938 782
90cceaf6 783 WriteDigits() ;
88cb7938 784
01a599c9 785 if(strstr(option,"deb"))
786 PrintDigits(option);
94de8339 787
788 //increment the total number of Digits per run
f898e0f3 789 fDigitsInRun += phosLoader->Digits()->GetEntriesFast() ;
88cb7938 790 }
ddd1a39c 791
8cb3533f 792 if(strstr(option,"tim")){
793 gBenchmark->Stop("PHOSDigitizer");
21cd0c07 794 TString message ;
795 message = " took %f seconds for Digitizing %f seconds per event\n" ;
351dd634 796 AliInfo(Form( message.Data(),
21cd0c07 797 gBenchmark->GetCpuTime("PHOSDigitizer"),
351dd634 798 gBenchmark->GetCpuTime("PHOSDigitizer")/nEvents ));
21cd0c07 799 }
990119d6 800}
7b7c1533 801//____________________________________________________________________________
f898e0f3 802Float_t AliPHOSDigitizer::TimeResolution(Float_t e){
803 //calculate TOF resolution using beam-test resutls
804 Float_t a=AliPHOSSimParam::GetInstance()->GetTOFa() ;
805 Float_t b=AliPHOSSimParam::GetInstance()->GetTOFb() ;
806 return TMath::Sqrt(a*a+b*b/e) ;
9688c1dd 807}
8d0f3f77 808
f898e0f3 809////____________________________________________________________________________
810//Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks) const
811//{
812// // Returns the shortest time among all time ticks
813//
814// ticks->Sort() ; //Sort in accordance with times of ticks
815// TIter it(ticks) ;
816// AliPHOSTick * ctick = (AliPHOSTick *) it.Next() ;
817// Float_t time = ctick->CrossingTime(fTimeThreshold) ;
818//
819// AliPHOSTick * t ;
820// while((t=(AliPHOSTick*) it.Next())){
821// if(t->GetTime() < time) //This tick starts before crossing
822// *ctick+=*t ;
823// else
824// return time ;
825//
826// time = ctick->CrossingTime(fTimeThreshold) ;
827// }
828// return time ;
829//}
830
9688c1dd 831//____________________________________________________________________________
3f81a70b 832Bool_t AliPHOSDigitizer::Init()
a4e98857 833{
fbf811ec 834 // Makes all memory allocations
88cb7938 835 fInit = kTRUE ;
f898e0f3 836
bfae5a5d 837 AliPHOSGeometry *geom;
838 if (!(geom = AliPHOSGeometry::GetInstance()))
839 geom = AliPHOSGeometry::GetInstance("IHEP","");
840// const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
b22e4735 841
88cb7938 842 fEmcCrystals = geom->GetNModules() * geom->GetNCristalsInModule() ;
8d0f3f77 843
45fa49ca 844 fFirstEvent = 0 ;
845 fLastEvent = fFirstEvent ;
f21fc003 846 if (fDigInput)
847 fInput = fDigInput->GetNinputs() ;
88cb7938 848 else
849 fInput = 1 ;
850
851 fInputFileNames = new TString[fInput] ;
852 fEventNames = new TString[fInput] ;
853 fInputFileNames[0] = GetTitle() ;
854 fEventNames[0] = fEventFolderName.Data() ;
855 Int_t index ;
856 for (index = 1 ; index < fInput ; index++) {
f21fc003 857 fInputFileNames[index] = static_cast<AliStream*>(fDigInput->GetInputStream(index))->GetFileName(0);
858 TString tempo = fDigInput->GetInputFolderName(index) ;
859 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added by fDigInput
8d0f3f77 860 }
88cb7938 861
862 //to prevent cleaning of this object while GetEvent is called
f898e0f3 863 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
864 if(!rl){
95a38b7d 865 AliRunLoader::Open(GetTitle(), fEventFolderName) ;
f898e0f3 866 }
88cb7938 867 return fInit ;
8d0f3f77 868}
869
870//____________________________________________________________________________
871void AliPHOSDigitizer::InitParameters()
872{
45fa49ca 873 // Set initial parameters Digitizer
0bc3b8ed 874
3758d9fc 875 fDigitsInRun = 0 ;
212d1c0f 876 SetEventRange(0,-1) ;
54ac223e 877 fPulse = new AliPHOSPulseGenerator();
878 fADCValuesLG = new Int_t[fPulse->GetRawFormatTimeBins()];
879 fADCValuesHG = new Int_t[fPulse->GetRawFormatTimeBins()];
8cb3533f 880
990119d6 881}
7b7c1533 882
990119d6 883//__________________________________________________________________
702ab87e 884void AliPHOSDigitizer::Print(const Option_t *)const
21cd0c07 885{
dd5c4038 886 // Print Digitizer's parameters
351dd634 887 AliInfo(Form("\n------------------- %s -------------", GetName() )) ;
88cb7938 888 if( strcmp(fEventFolderName.Data(), "") != 0 ){
889 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
890
891 Int_t nStreams ;
f21fc003 892 if (fDigInput)
88cb7938 893 nStreams = GetNInputStreams() ;
894 else
895 nStreams = fInput ;
896
897 Int_t index = 0 ;
898 for (index = 0 ; index < nStreams ; index++) {
899 TString tempo(fEventNames[index]) ;
900 tempo += index ;
f898e0f3 901 printf ("Adding SDigits from %s \n", fInputFileNames[index].Data()) ;
88cb7938 902 }
88cb7938 903
f898e0f3 904 // printf("\nWith following parameters:\n") ;
905 // printf(" Electronics noise in EMC (fPinNoise) = %f GeV\n", fPinNoise ) ;
906 // printf(" Threshold in EMC (fEMCDigitThreshold) = %f GeV\n", fEMCDigitThreshold ) ;
907 // printf(" Noise in CPV (fCPVNoise) = %f aux units\n", fCPVNoise ) ;
908 // printf(" Threshold in CPV (fCPVDigitThreshold) = %f aux units\n",fCPVDigitThreshold ) ;
88cb7938 909 printf(" ---------------------------------------------------\n") ;
990119d6 910 }
8cb3533f 911 else
351dd634 912 AliInfo(Form("AliPHOSDigitizer not initialized" )) ;
8cb3533f 913
914}
88cb7938 915
8cb3533f 916//__________________________________________________________________
21cd0c07 917 void AliPHOSDigitizer::PrintDigits(Option_t * option)
918{
3bf72d32 919 // Print a table of digits
21cd0c07 920
f898e0f3 921
922 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 923 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 924 TClonesArray * digits = phosLoader->Digits() ;
925 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
3bf72d32 926
351dd634 927 AliInfo(Form("%d", digits->GetEntriesFast())) ;
88cb7938 928 printf("\nevent %d", gAlice->GetEvNumber()) ;
929 printf("\n Number of entries in Digits list %d", digits->GetEntriesFast() ) ;
930
11f9c5ff 931
3bf72d32 932 if(strstr(option,"all")||strstr(option,"EMC")){
8cb3533f 933 //loop over digits
934 AliPHOSDigit * digit;
88cb7938 935 printf("\nEMC digits (with primaries):\n") ;
936 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
f898e0f3 937 Int_t maxEmc = geom->GetNModules()*geom->GetNCristalsInModule() ;
8cb3533f 938 Int_t index ;
a6eedfad 939 for (index = 0 ; (index < digits->GetEntriesFast()) &&
97e75f77 940 (static_cast<AliPHOSDigit *>(digits->At(index))->GetId() <= maxEmc) ; index++) {
7b7c1533 941 digit = (AliPHOSDigit * ) digits->At(index) ;
21cd0c07 942 if(digit->GetNprimary() == 0)
943 continue;
27a73a5d 944// printf("%6d %8d %6.5e %4d %2d :",
945// digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ; // YVK
946 printf("%6d %.4f %6.5e %4d %2d :",
947 digit->GetId(), digit->GetEnergy(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
8cb3533f 948 Int_t iprimary;
21cd0c07 949 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
88cb7938 950 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
21cd0c07 951 }
81d5f731 952 printf("\n") ;
21cd0c07 953 }
9688c1dd 954 }
3bf72d32 955
9688c1dd 956 if(strstr(option,"all")||strstr(option,"CPV")){
8cb3533f 957
9688c1dd 958 //loop over CPV digits
959 AliPHOSDigit * digit;
88cb7938 960 printf("\nCPV digits (with primaries):\n") ;
961 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
f898e0f3 962 Int_t maxEmc = geom->GetNModules()*geom->GetNCristalsInModule() ;
9688c1dd 963 Int_t index ;
a6eedfad 964 for (index = 0 ; index < digits->GetEntriesFast(); index++) {
9688c1dd 965 digit = (AliPHOSDigit * ) digits->At(index) ;
966 if(digit->GetId() > maxEmc){
81d5f731 967 printf("%6d %8d %4d %2d :",
11f9c5ff 968 digit->GetId(), digit->GetAmp(), digit->GetIndexInList(), digit->GetNprimary()) ;
9688c1dd 969 Int_t iprimary;
21cd0c07 970 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
88cb7938 971 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
21cd0c07 972 }
81d5f731 973 printf("\n") ;
21cd0c07 974 }
9688c1dd 975 }
8cb3533f 976 }
88cb7938 977
8cb3533f 978}
7b7c1533 979
9688c1dd 980//__________________________________________________________________
0bc3b8ed 981Float_t AliPHOSDigitizer::TimeOfNoise(void) const
9688c1dd 982{ // Calculates the time signal generated by noise
26a2ef9d 983 //PH Info("TimeOfNoise", "Change me") ;
04f0bda3 984 return gRandom->Rndm() * 1.28E-5;
9688c1dd 985}
7b7c1533 986
88cb7938 987//__________________________________________________________________
988void AliPHOSDigitizer::Unload()
989{
990
991 Int_t i ;
992 for(i = 1 ; i < fInput ; i++){
993 TString tempo(fEventNames[i]) ;
994 tempo += i ;
f898e0f3 995 AliRunLoader* rl = AliRunLoader::GetRunLoader(tempo) ;
97e75f77 996 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 997 phosLoader->UnloadSDigits() ;
88cb7938 998 }
999
f898e0f3 1000 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 1001 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 1002 phosLoader->UnloadDigits() ;
88cb7938 1003}
1004
7b7c1533 1005//____________________________________________________________________________
90cceaf6 1006void AliPHOSDigitizer::WriteDigits()
7b7c1533 1007{
1008
1009 // Makes TreeD in the output file.
1010 // Check if branch already exists:
1011 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
1012 // already existing branches.
1013 // else creates branch with Digits, named "PHOS", title "...",
1014 // and branch "AliPHOSDigitizer", with the same title to keep all the parameters
1015 // and names of files, from which digits are made.
1016
f898e0f3 1017 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 1018 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 1019
1020 const TClonesArray * digits = phosLoader->Digits() ;
1021 TTree * treeD = phosLoader->TreeD();
1022 if(!treeD){
1023 phosLoader->MakeTree("D");
1024 treeD = phosLoader->TreeD();
1025 }
1026
7b7c1533 1027 // -- create Digits branch
1028 Int_t bufferSize = 32000 ;
2524c56f 1029 TBranch * digitsBranch = treeD->Branch("PHOS","TClonesArray",&digits,bufferSize);
88cb7938 1030 digitsBranch->SetTitle(fEventFolderName);
1031 digitsBranch->Fill() ;
fbf811ec 1032
f898e0f3 1033 phosLoader->WriteDigits("OVERWRITE");
88cb7938 1034
1035 Unload() ;
b3690abb 1036
7b7c1533 1037}