Removing the tasks from the digitization (Ruben)
[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),
207 fInputFileNames(0x0),//?
208 fEventNames(0x0),//?
209 fEmcCrystals(d.fEmcCrystals),
3663622c 210 fEventFolderName(d.fEventFolderName),
211 fFirstEvent(d.fFirstEvent),
ddd1a39c 212 fLastEvent(d.fLastEvent),
f898e0f3 213 fcdb (0x0),
54ac223e 214 fEventCounter(0),
215 fPulse(0),
216 fADCValuesLG(0),
217 fADCValuesHG(0)
88cb7938 218{
219 // copyy ctor
88cb7938 220 SetName(d.GetName()) ;
221 SetTitle(d.GetTitle()) ;
f898e0f3 222 fcdb = new AliPHOSCalibData(-1);
990119d6 223}
224
990119d6 225//____________________________________________________________________________
f21fc003 226AliPHOSDigitizer::AliPHOSDigitizer(AliDigitizationInput * rd) :
227 AliDigitizer(rd,"PHOSDigitizer"),
3663622c 228 fDefaultInit(kFALSE),
229 fDigitsInRun(0),
230 fInit(kFALSE),
231 fInput(0),
232 fInputFileNames(0x0),
233 fEventNames(0x0),
234 fEmcCrystals(0),
f21fc003 235 fEventFolderName(fDigInput->GetInputFolderName(0)),
3663622c 236 fFirstEvent(0),
ddd1a39c 237 fLastEvent(0),
f898e0f3 238 fcdb (0x0),
54ac223e 239 fEventCounter(0),
240 fPulse(0),
241 fADCValuesLG(0),
242 fADCValuesHG(0)
ddd1a39c 243
990119d6 244{
45fa49ca 245 // ctor Init() is called by RunDigitizer
f21fc003 246 fDigInput = rd ;
247 SetTitle(static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetFileName(0));
b22e4735 248 InitParameters() ;
fbf811ec 249 fDefaultInit = kFALSE ;
f898e0f3 250 fcdb = new AliPHOSCalibData(-1);
990119d6 251}
252
253//____________________________________________________________________________
254 AliPHOSDigitizer::~AliPHOSDigitizer()
255{
f21fc003 256 // dtor
88cb7938 257 delete [] fInputFileNames ;
258 delete [] fEventNames ;
ddd1a39c 259
54ac223e 260 delete fPulse;
261 delete [] fADCValuesLG;
262 delete [] fADCValuesHG;
263
f898e0f3 264 if(fcdb){ delete fcdb ; fcdb=0;}
ddd1a39c 265
990119d6 266}
267
268//____________________________________________________________________________
fc7e2f43 269void AliPHOSDigitizer::Digitize(Int_t event)
a4e98857 270{
271
272 // Makes the digitization of the collected summable digits.
273 // It first creates the array of all PHOS modules
dc986a1d 274 // filled with noise (different for EMC, and CPV) and
a4e98857 275 // then adds contributions from SDigits.
276 // This design avoids scanning over the list of digits to add
277 // contribution to new SDigits only.
990119d6 278
f898e0f3 279 Bool_t toMakeNoise = kTRUE ; //Do not create noisy digits if merge with real data
280
281 //First stream
282 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 283 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 284
285 Int_t readEvent = event ;
f21fc003 286 if (fDigInput)
287 readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(0))->GetCurrentEventNumber() ;
d6e8d7d3 288 AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
f898e0f3 289 readEvent, GetTitle(), fEventFolderName.Data())) ;
290 rl->GetEvent(readEvent) ;
291 phosLoader->CleanSDigits() ;
292 phosLoader->LoadSDigits("READ") ;
293
294 //Prepare Output
295 TClonesArray * digits = phosLoader->Digits() ;
296 if( !digits ) {
297 phosLoader->MakeDigitsArray() ;
298 digits = phosLoader->Digits() ;
299 }
300
7b7c1533 301 digits->Clear() ;
990119d6 302
f898e0f3 303 //
304 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
990119d6 305 //Making digits with noise, first EMC
e250de8f 306 //Check which PHOS modules are present
307 Bool_t isPresent[5] ;
308 TString volpath ;
309 Int_t nmod=0 ;
310 for(Int_t i=0; i<5; i++){
311 volpath = "/ALIC_1/PHOS_";
312 volpath += i+1;
313 if (gGeoManager->CheckPath(volpath.Data())) {
314 isPresent[i]=1 ;
315 nmod++ ;
316 }
317 else{
318 isPresent[i]=0 ;
319 }
320 }
321
322 Int_t nEMC = nmod*geom->GetNPhi()*geom->GetNZ();
990119d6 323
324 Int_t nCPV ;
990119d6 325 Int_t absID ;
990119d6 326
e250de8f 327 //check if CPV exists
328 Bool_t isCPVpresent=0 ;
329 for(Int_t i=1; i<=5 && !isCPVpresent; i++){
330 volpath = "/ALIC_1/PHOS_";
331 volpath += i;
332 volpath += "/PCPV_1";
333 if (gGeoManager->CheckPath(volpath.Data()))
334 isCPVpresent=1 ;
335 }
88cb7938 336
e250de8f 337 if(isCPVpresent){
338 nCPV = nEMC + geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() * nmod ;
339 }
340 else{
341 nCPV = nEMC ;
342 }
343
9688c1dd 344 digits->Expand(nCPV) ;
8cb3533f 345
88cb7938 346 //take all the inputs to add together and load the SDigits
347 TObjArray * sdigArray = new TObjArray(fInput) ;
f898e0f3 348 sdigArray->AddAt(phosLoader->SDigits(), 0) ;
349
350 for(Int_t i = 1 ; i < fInput ; i++){
88cb7938 351 TString tempo(fEventNames[i]) ;
352 tempo += i ;
f898e0f3 353 AliRunLoader* rl2 = AliRunLoader::GetRunLoader(tempo) ;
354 if(!rl2){
355 rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
356 if (!rl2) {
357 Fatal("AliPHOSDigitizer", "Could not find the Run Loader for %s - %s",fInputFileNames[i].Data(), tempo.Data()) ;
358 return ;
359 }
360 rl2->LoadHeader();
361 }
97e75f77 362 AliPHOSLoader * phosLoader2 = static_cast<AliPHOSLoader*>(rl2->GetLoader("PHOSLoader"));
f898e0f3 363
f21fc003 364 if(fDigInput){
365 readEvent = static_cast<AliStream*>(fDigInput->GetInputStream(i))->GetCurrentEventNumber() ;
f898e0f3 366 }
367 TClonesArray * digs ;
368 if(AliPHOSSimParam::GetInstance()->IsStreamDigits(i)){ //This is Digits Stream
369 AliInfo(Form("Adding event %d from input stream %d %s %s",
370 readEvent, i, fInputFileNames[i].Data(), tempo.Data())) ;
371 rl2->GetEvent(readEvent) ;
372 phosLoader2->CleanDigits() ;
373 phosLoader2->LoadDigits("READ") ;
374 digs = phosLoader2->Digits() ;
375 toMakeNoise=0 ; //Do not add noise, it is already in stream
376 }
377 else{
378 AliInfo(Form("Adding event %d (SDigits) from input stream %d %s %s",
379 readEvent, i, fInputFileNames[i].Data(), tempo.Data())) ;
380 rl2->GetEvent(readEvent) ;
381 phosLoader2->CleanSDigits() ;
382 phosLoader2->LoadSDigits("READ") ;
383 digs = phosLoader2->SDigits() ;
384 }
385 sdigArray->AddAt(digs, i) ;
38bb0fd5 386 }
9688c1dd 387
27a73a5d 388 //Find the first crystal with signal
9688c1dd 389 Int_t nextSig = 200000 ;
88cb7938 390 TClonesArray * sdigits ;
f898e0f3 391 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 392 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
a6eedfad 393 if ( !sdigits->GetEntriesFast() )
7a9d98f9 394 continue ;
97e75f77 395 Int_t curNext = static_cast<AliPHOSDigit *>(sdigits->At(0))->GetId() ;
88cb7938 396 if(curNext < nextSig)
397 nextSig = curNext ;
9688c1dd 398 }
88cb7938 399
400 TArrayI index(fInput) ;
9688c1dd 401 index.Reset() ; //Set all indexes to zero
88cb7938 402
9688c1dd 403 AliPHOSDigit * digit ;
404 AliPHOSDigit * curSDigit ;
88cb7938 405
f898e0f3 406// TClonesArray * ticks = new TClonesArray("AliPHOSTick",1000) ;
88cb7938 407
9688c1dd 408 //Put Noise contribution
f898e0f3 409 Double_t apdNoise = 0. ;
410 if(toMakeNoise)
411 apdNoise = AliPHOSSimParam::GetInstance()->GetAPDNoise() ;
412
e250de8f 413 Int_t emcpermod=geom->GetNPhi()*geom->GetNZ();
414 Int_t idigit= 0;
415 for(Int_t imod=0; imod<5; imod++){
416 if(!isPresent[imod])
417 continue ;
418 Int_t firstAbsId=imod*emcpermod+1 ;
419 Int_t lastAbsId =(imod+1)*emcpermod ;
420 for(absID = firstAbsId ; absID <= lastAbsId ; absID++){
421 Float_t noise = gRandom->Gaus(0.,apdNoise) ;
422 new((*digits)[idigit]) AliPHOSDigit( -1, absID, noise, TimeOfNoise() ) ;
423 //look if we have to add signal?
97e75f77 424 digit = static_cast<AliPHOSDigit *>(digits->At(idigit)) ;
e250de8f 425 idigit++ ;
88cb7938 426
e250de8f 427 if(absID==nextSig){
9688c1dd 428 //Add SDigits from all inputs
f898e0f3 429// ticks->Clear() ;
430// Int_t contrib = 0 ;
431
432//New Timing model is necessary
433// Float_t a = digit->GetEnergy() ;
434// Float_t b = TMath::Abs( a / fTimeSignalLength) ;
435// //Mark the beginning of the signal
436// new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime(),0, b);
437// //Mark the end of the signal
438// new((*ticks)[contrib++]) AliPHOSTick(digit->GetTime()+fTimeSignalLength, -a, -b);
439
440// Calculate time as time of the largest digit
e250de8f 441 Float_t time = digit->GetTime() ;
442 Float_t eTime= digit->GetEnergy() ;
88cb7938 443
e250de8f 444 //loop over inputs
445 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 446 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] ){
447 curSDigit = static_cast<AliPHOSDigit*>(static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
737c795f 448 if(AliPHOSSimParam::GetInstance()->IsStreamDigits(i)){ //This is Digits Stream
449 curSDigit->SetEnergy(Calibrate(curSDigit->GetEnergy(),curSDigit->GetId())) ;
6f47f50d 450 curSDigit->SetTime(CalibrateT(curSDigit->GetTime(),curSDigit->GetId())) ;
737c795f 451 }
452 }
9688c1dd 453 else
e250de8f 454 curSDigit = 0 ;
455 //May be several digits will contribute from the same input
456 while(curSDigit && curSDigit->GetId() == absID){
457 //Shift primary to separate primaries belonging different inputs
458 Int_t primaryoffset ;
f21fc003 459 if(fDigInput)
460 primaryoffset = fDigInput->GetMask(i) ;
e250de8f 461 else
462 primaryoffset = 10000000*i ;
463 curSDigit->ShiftPrimary(primaryoffset) ;
7437a0f7 464
f898e0f3 465//New Timing model is necessary
466// a = curSDigit->GetEnergy() ;
467// b = a /fTimeSignalLength ;
468// new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime(),0, b);
469// new((*ticks)[contrib++]) AliPHOSTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
470 if(curSDigit->GetEnergy()>eTime){
471 eTime=curSDigit->GetEnergy() ;
472 time=curSDigit->GetTime() ;
473 }
e250de8f 474 *digit += *curSDigit ; //add energies
475
476 index[i]++ ;
97e75f77 477 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
478 curSDigit = static_cast<AliPHOSDigit*>(static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
e250de8f 479 else
480 curSDigit = 0 ;
481 }
482 }
88cb7938 483
e250de8f 484 //calculate and set time
f898e0f3 485//New Timing model is necessary
486// Float_t time = FrontEdgeTime(ticks) ;
e250de8f 487 digit->SetTime(time) ;
88cb7938 488
e250de8f 489 //Find next signal module
490 nextSig = 200000 ;
491 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 492 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
e250de8f 493 Int_t curNext = nextSig ;
494 if(sdigits->GetEntriesFast() > index[i] ){
97e75f77 495 curNext = static_cast<AliPHOSDigit *>(sdigits->At(index[i]))->GetId() ;
e250de8f 496 }
497 if(curNext < nextSig) nextSig = curNext ;
498 }
7b7c1533 499 }
500 }
990119d6 501 }
f898e0f3 502
dde7e19f 503
504 //Apply non-linearity
505 if(AliPHOSSimParam::GetInstance()->IsCellNonlinearityOn()){ //Apply non-lineairyt on cell level
506 const Double_t aNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyA() ;
507 const Double_t bNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyB() ;
9d68672f 508 const Double_t cNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyC() ;
dde7e19f 509 for(Int_t i = 0 ; i < nEMC ; i++){
510 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
511 Double_t e= digit->GetEnergy() ;
512 // version(1) digit->SetEnergy(e*(1+a*TMath::Exp(-e/b))) ;
9d68672f 513 digit->SetEnergy(e*cNL*(1.+aNL*TMath::Exp(-e*e/2./bNL/bNL))) ; //Better agreement with data...
dde7e19f 514 }
515 }
516
517
f898e0f3 518 //distretize energy if necessary
519 if(AliPHOSSimParam::GetInstance()->IsEDigitizationOn()){
520 Float_t adcW=AliPHOSSimParam::GetInstance()->GetADCchannelW() ;
521 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 522 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
f898e0f3 523 digit->SetEnergy(adcW*ceil(digit->GetEnergy()/adcW)) ;
524 }
525 }
dde7e19f 526
737c795f 527 //Apply decalibration if necessary
528 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 529 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
737c795f 530 Decalibrate(digit) ;
167d2780 531 }
3f81a70b 532
f898e0f3 533// ticks->Delete() ;
534// delete ticks ;
88cb7938 535
9688c1dd 536 //Now CPV digits (different noise and no timing)
e250de8f 537 Int_t cpvpermod = geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() ;
538 Int_t nEMCtotal=emcpermod*5 ;
f898e0f3 539 Float_t cpvNoise = AliPHOSSimParam::GetInstance()->GetCPVNoise() ;
e250de8f 540 if(isCPVpresent){ //CPV is present in current geometry
541 for(Int_t imod=0; imod<5; imod++){ //module is present in current geometry
542 if(!isPresent[imod])
543 continue ;
544 Int_t firstAbsId=nEMCtotal+imod*cpvpermod+1 ;
545 Int_t lastAbsId =nEMCtotal+(imod+1)*cpvpermod ;
546 for(absID = firstAbsId; absID <= lastAbsId; absID++){
547 Float_t noise = gRandom->Gaus(0., cpvNoise) ;
548 new((*digits)[idigit]) AliPHOSDigit( -1,absID,noise, TimeOfNoise() ) ;
549 idigit++ ;
550 //look if we have to add signal?
551 if(absID==nextSig){
97e75f77 552 digit = static_cast<AliPHOSDigit *>(digits->At(idigit-1)) ;
e250de8f 553 //Add SDigits from all inputs
554 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 555 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
556 curSDigit = static_cast<AliPHOSDigit*>( static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
e250de8f 557 else
558 curSDigit = 0 ;
559
560 //May be several digits will contribute from the same input
561 while(curSDigit && curSDigit->GetId() == absID){
562 //Shift primary to separate primaries belonging different inputs
563 Int_t primaryoffset ;
f21fc003 564 if(fDigInput)
565 primaryoffset = fDigInput->GetMask(i) ;
e250de8f 566 else
567 primaryoffset = 10000000*i ;
568 curSDigit->ShiftPrimary(primaryoffset) ;
569
570 //add energies
571 *digit += *curSDigit ;
572 index[i]++ ;
97e75f77 573 if( static_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
574 curSDigit = static_cast<AliPHOSDigit*>( static_cast<TClonesArray *>(sdigArray->At(i))->At(index[i]) ) ;
e250de8f 575 else
576 curSDigit = 0 ;
577 }
578 }
a6eedfad 579
e250de8f 580 //Find next signal module
581 nextSig = 200000 ;
582 for(Int_t i = 0 ; i < fInput ; i++){
97e75f77 583 sdigits = static_cast<TClonesArray *>(sdigArray->At(i)) ;
e250de8f 584 Int_t curNext = nextSig ;
585 if(sdigits->GetEntriesFast() > index[i] )
97e75f77 586 curNext = static_cast<AliPHOSDigit *>( sdigits->At(index[i]) )->GetId() ;
e250de8f 587 if(curNext < nextSig) nextSig = curNext ;
588 }
9688c1dd 589
e250de8f 590 }
591 }
9688c1dd 592 }
593 }
88cb7938 594
595 delete sdigArray ; //We should not delete its contents
9688c1dd 596
1dfe0f3c 597 Int_t relId[4];
598
599 //set amplitudes in bad channels to zero
f898e0f3 600
65fd5dc1 601 for(Int_t i = 0 ; i <digits->GetEntriesFast(); i++){
97e75f77 602 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
f898e0f3 603 geom->AbsToRelNumbering(digit->GetId(),relId);
1dfe0f3c 604 if(relId[1] == 0) // Emc
f898e0f3 605 if(fcdb->IsBadChannelEmc(relId[0],relId[3],relId[2])) digit->SetEnergy(0.);
1dfe0f3c 606 }
607
990119d6 608 //remove digits below thresholds
f898e0f3 609 Float_t emcThreshold = AliPHOSSimParam::GetInstance()->GetEmcDigitsThreshold() ;
610 for(Int_t i = 0 ; i < nEMC ; i++){
97e75f77 611 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
a28333c5 612
f898e0f3 613 if(digit->GetEnergy() < emcThreshold){
a6eedfad 614 digits->RemoveAt(i) ;
f898e0f3 615 continue ;
616 }
6f47f50d 617
54ac223e 618 geom->AbsToRelNumbering(digit->GetId(),relId);
619
dde7e19f 620// digit->SetEnergy(TMath::Ceil(digit->GetEnergy())-0.9999) ;
6f47f50d 621
f898e0f3 622 Float_t tres = TimeResolution(digit->GetEnergy()) ;
623 digit->SetTime(gRandom->Gaus(digit->GetTime(), tres) ) ;
54ac223e 624
625 fPulse->Reset();
626 fPulse->SetAmplitude(digit->GetEnergy()/
627 fcdb->GetADCchannelEmc(relId[0],relId[3],relId[2]));
628 fPulse->SetTZero(digit->GetTimeR());
629 fPulse->MakeSamples();
630 fPulse->GetSamples(fADCValuesHG, fADCValuesLG) ;
631 Int_t nSamples = fPulse->GetRawFormatTimeBins();
632 digit->SetALTROSamplesHG(nSamples,fADCValuesHG);
633 digit->SetALTROSamplesLG(nSamples,fADCValuesLG);
aaf8a71c 634 }
635
f898e0f3 636 Float_t cpvDigitThreshold = AliPHOSSimParam::GetInstance()->GetCpvDigitsThreshold() ;
637 for(Int_t i = nEMC; i < nCPV ; i++){
97e75f77 638 if( static_cast<AliPHOSDigit*>(digits->At(i))->GetEnergy() < cpvDigitThreshold )
a6eedfad 639 digits->RemoveAt(i) ;
f898e0f3 640 }
9688c1dd 641
7b7c1533 642 digits->Compress() ;
7b7c1533 643 Int_t ndigits = digits->GetEntriesFast() ;
a91822a8 644
3758d9fc 645 //Set indexes in list of digits and make true digitization of the energy
f898e0f3 646 for (Int_t i = 0 ; i < ndigits ; i++) {
97e75f77 647 digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
990119d6 648 digit->SetIndexInList(i) ;
27a73a5d 649 if(digit->GetId() > fEmcCrystals){ //digitize CPV only
877695e7 650 digit->SetAmp(DigitizeCPV(digit->GetEnergy(),digit->GetId()) ) ;
27a73a5d 651 }
990119d6 652 }
f898e0f3 653
7b7c1533 654}
737c795f 655//____________________________________________________________________________
656Float_t AliPHOSDigitizer::Calibrate(Float_t amp,Int_t absId){
657 //Apply calibration
658 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
548f0134 659
737c795f 660 //Determine rel.position of the cell absolute ID
661 Int_t relId[4];
662 geom->AbsToRelNumbering(absId,relId);
663 Int_t module=relId[0];
664 Int_t row =relId[2];
665 Int_t column=relId[3];
666 if(relId[1]==0){ //This Is EMC
667 Float_t calibration = fcdb->GetADCchannelEmc(module,column,row);
668 return amp*calibration ;
669 }
670 return 0 ;
671}
3758d9fc 672//____________________________________________________________________________
737c795f 673void AliPHOSDigitizer::Decalibrate(AliPHOSDigit *digit)
3758d9fc 674{
877695e7 675 // Decalibrate EMC digit, i.e. change its energy by a factor read from CDB
676
f898e0f3 677 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
877695e7 678
679 //Determine rel.position of the cell absolute ID
680 Int_t relId[4];
f898e0f3 681 geom->AbsToRelNumbering(digit->GetId(),relId);
877695e7 682 Int_t module=relId[0];
683 Int_t row =relId[2];
684 Int_t column=relId[3];
737c795f 685 if(relId[1]==0){ //This Is EMC
b30d19db 686 Float_t decalib = fcdb->GetADCchannelEmcDecalib(module,column,row); // O(1)
687 Float_t calibration = fcdb->GetADCchannelEmc(module,column,row)*decalib;
737c795f 688 Float_t energy = digit->GetEnergy()/calibration;
689 digit->SetEnergy(energy); //Now digit measures E in ADC counts
6f47f50d 690 Float_t time = digit->GetTime() ;
691 time-=fcdb->GetTimeShiftEmc(module,column,row);
692 digit->SetTime(time) ;
737c795f 693 }
877695e7 694}
695//____________________________________________________________________________
6f47f50d 696Float_t AliPHOSDigitizer::CalibrateT(Float_t time,Int_t absId){
697 //Apply time calibration
698 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
699
700 //Determine rel.position of the cell absolute ID
701 Int_t relId[4];
702 geom->AbsToRelNumbering(absId,relId);
703 Int_t module=relId[0];
704 Int_t row =relId[2];
705 Int_t column=relId[3];
706 time += fcdb->GetTimeShiftEmc(module,column,row);
707 return time ;
708}
709//____________________________________________________________________________
877695e7 710Int_t AliPHOSDigitizer::DigitizeCPV(Float_t charge, Int_t absId)
711{
712 // Returns digitized value of the CPV charge in a pad absId
0bc3b8ed 713
f898e0f3 714 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
fc6706cb 715
a8ec0771 716 //Determine rel.position of the cell absId
717 Int_t relId[4];
f898e0f3 718 geom->AbsToRelNumbering(absId,relId);
a8ec0771 719 Int_t module=relId[0];
27a73a5d 720 Int_t row =relId[2];
a8ec0771 721 Int_t column=relId[3];
722
877695e7 723 Int_t channel = 0;
a8ec0771 724
877695e7 725 if(absId > fEmcCrystals){ //digitize CPV only
a8ec0771 726
727 //reading calibration data for cell absId.
f898e0f3 728 Float_t adcPedestalCpv = fcdb->GetADCpedestalCpv(module,column,row);
729 Float_t adcChanelCpv = fcdb->GetADCchannelCpv( module,column,row);
a8ec0771 730
f898e0f3 731 channel = (Int_t) TMath::Ceil((charge - adcPedestalCpv)/adcChanelCpv) ;
732 Int_t nMax = AliPHOSSimParam::GetInstance()->GetNADCcpv() ;
733 if(channel > nMax ) channel = nMax ;
3758d9fc 734 }
877695e7 735 return channel ;
3758d9fc 736}
548f0134 737
7b7c1533 738//____________________________________________________________________________
f21fc003 739void AliPHOSDigitizer::Digitize(Option_t *option)
7b7c1533 740{
212d1c0f 741 // Steering method to process digitization for events
742 // in the range from fFirstEvent to fLastEvent.
743 // This range is optionally set by SetEventRange().
45fa49ca 744 // if fLastEvent=-1, then process events until the end.
745 // by default fLastEvent = fFirstEvent (process only one event)
88cb7938 746
747 if (!fInit) { // to prevent overwrite existing file
351dd634 748 AliError(Form("Give a version name different from %s",
749 fEventFolderName.Data() )) ;
88cb7938 750 return ;
751 }
990119d6 752
7b7c1533 753 if (strstr(option,"print")) {
88cb7938 754 Print();
7b7c1533 755 return ;
8cb3533f 756 }
990119d6 757
8661738e 758 if(strstr(option,"tim"))
759 gBenchmark->Start("PHOSDigitizer");
3f81a70b 760
f898e0f3 761 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 762 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
5b4d2c50 763
212d1c0f 764 if (fLastEvent == -1)
f898e0f3 765 fLastEvent = rl->GetNumberOfEvents() - 1 ;
f21fc003 766 else if (fDigInput)
396a348e 767 fLastEvent = fFirstEvent ;
45fa49ca 768
212d1c0f 769 Int_t nEvents = fLastEvent - fFirstEvent + 1;
770
7b7c1533 771 Int_t ievent ;
88cb7938 772
212d1c0f 773 for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
ddd1a39c 774 fEventCounter++ ;
b22e4735 775
7b7c1533 776 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
88cb7938 777
90cceaf6 778 WriteDigits() ;
88cb7938 779
01a599c9 780 if(strstr(option,"deb"))
781 PrintDigits(option);
94de8339 782
783 //increment the total number of Digits per run
f898e0f3 784 fDigitsInRun += phosLoader->Digits()->GetEntriesFast() ;
88cb7938 785 }
ddd1a39c 786
8cb3533f 787 if(strstr(option,"tim")){
788 gBenchmark->Stop("PHOSDigitizer");
21cd0c07 789 TString message ;
790 message = " took %f seconds for Digitizing %f seconds per event\n" ;
351dd634 791 AliInfo(Form( message.Data(),
21cd0c07 792 gBenchmark->GetCpuTime("PHOSDigitizer"),
351dd634 793 gBenchmark->GetCpuTime("PHOSDigitizer")/nEvents ));
21cd0c07 794 }
990119d6 795}
7b7c1533 796//____________________________________________________________________________
f898e0f3 797Float_t AliPHOSDigitizer::TimeResolution(Float_t e){
798 //calculate TOF resolution using beam-test resutls
799 Float_t a=AliPHOSSimParam::GetInstance()->GetTOFa() ;
800 Float_t b=AliPHOSSimParam::GetInstance()->GetTOFb() ;
801 return TMath::Sqrt(a*a+b*b/e) ;
9688c1dd 802}
8d0f3f77 803
f898e0f3 804////____________________________________________________________________________
805//Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks) const
806//{
807// // Returns the shortest time among all time ticks
808//
809// ticks->Sort() ; //Sort in accordance with times of ticks
810// TIter it(ticks) ;
811// AliPHOSTick * ctick = (AliPHOSTick *) it.Next() ;
812// Float_t time = ctick->CrossingTime(fTimeThreshold) ;
813//
814// AliPHOSTick * t ;
815// while((t=(AliPHOSTick*) it.Next())){
816// if(t->GetTime() < time) //This tick starts before crossing
817// *ctick+=*t ;
818// else
819// return time ;
820//
821// time = ctick->CrossingTime(fTimeThreshold) ;
822// }
823// return time ;
824//}
825
9688c1dd 826//____________________________________________________________________________
3f81a70b 827Bool_t AliPHOSDigitizer::Init()
a4e98857 828{
fbf811ec 829 // Makes all memory allocations
88cb7938 830 fInit = kTRUE ;
f898e0f3 831
bfae5a5d 832 AliPHOSGeometry *geom;
833 if (!(geom = AliPHOSGeometry::GetInstance()))
834 geom = AliPHOSGeometry::GetInstance("IHEP","");
835// const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
b22e4735 836
88cb7938 837 fEmcCrystals = geom->GetNModules() * geom->GetNCristalsInModule() ;
8d0f3f77 838
45fa49ca 839 fFirstEvent = 0 ;
840 fLastEvent = fFirstEvent ;
f21fc003 841 if (fDigInput)
842 fInput = fDigInput->GetNinputs() ;
88cb7938 843 else
844 fInput = 1 ;
845
846 fInputFileNames = new TString[fInput] ;
847 fEventNames = new TString[fInput] ;
848 fInputFileNames[0] = GetTitle() ;
849 fEventNames[0] = fEventFolderName.Data() ;
850 Int_t index ;
851 for (index = 1 ; index < fInput ; index++) {
f21fc003 852 fInputFileNames[index] = static_cast<AliStream*>(fDigInput->GetInputStream(index))->GetFileName(0);
853 TString tempo = fDigInput->GetInputFolderName(index) ;
854 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added by fDigInput
8d0f3f77 855 }
88cb7938 856
857 //to prevent cleaning of this object while GetEvent is called
f898e0f3 858 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
859 if(!rl){
860 rl = AliRunLoader::Open(GetTitle(), fEventFolderName) ;
861 }
88cb7938 862 return fInit ;
8d0f3f77 863}
864
865//____________________________________________________________________________
866void AliPHOSDigitizer::InitParameters()
867{
45fa49ca 868 // Set initial parameters Digitizer
0bc3b8ed 869
3758d9fc 870 fDigitsInRun = 0 ;
212d1c0f 871 SetEventRange(0,-1) ;
54ac223e 872 fPulse = new AliPHOSPulseGenerator();
873 fADCValuesLG = new Int_t[fPulse->GetRawFormatTimeBins()];
874 fADCValuesHG = new Int_t[fPulse->GetRawFormatTimeBins()];
8cb3533f 875
990119d6 876}
7b7c1533 877
990119d6 878//__________________________________________________________________
702ab87e 879void AliPHOSDigitizer::Print(const Option_t *)const
21cd0c07 880{
dd5c4038 881 // Print Digitizer's parameters
351dd634 882 AliInfo(Form("\n------------------- %s -------------", GetName() )) ;
88cb7938 883 if( strcmp(fEventFolderName.Data(), "") != 0 ){
884 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
885
886 Int_t nStreams ;
f21fc003 887 if (fDigInput)
88cb7938 888 nStreams = GetNInputStreams() ;
889 else
890 nStreams = fInput ;
891
892 Int_t index = 0 ;
893 for (index = 0 ; index < nStreams ; index++) {
894 TString tempo(fEventNames[index]) ;
895 tempo += index ;
f898e0f3 896 printf ("Adding SDigits from %s \n", fInputFileNames[index].Data()) ;
88cb7938 897 }
88cb7938 898
f898e0f3 899 // printf("\nWith following parameters:\n") ;
900 // printf(" Electronics noise in EMC (fPinNoise) = %f GeV\n", fPinNoise ) ;
901 // printf(" Threshold in EMC (fEMCDigitThreshold) = %f GeV\n", fEMCDigitThreshold ) ;
902 // printf(" Noise in CPV (fCPVNoise) = %f aux units\n", fCPVNoise ) ;
903 // printf(" Threshold in CPV (fCPVDigitThreshold) = %f aux units\n",fCPVDigitThreshold ) ;
88cb7938 904 printf(" ---------------------------------------------------\n") ;
990119d6 905 }
8cb3533f 906 else
351dd634 907 AliInfo(Form("AliPHOSDigitizer not initialized" )) ;
8cb3533f 908
909}
88cb7938 910
8cb3533f 911//__________________________________________________________________
21cd0c07 912 void AliPHOSDigitizer::PrintDigits(Option_t * option)
913{
3bf72d32 914 // Print a table of digits
21cd0c07 915
f898e0f3 916
917 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 918 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 919 TClonesArray * digits = phosLoader->Digits() ;
920 const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
3bf72d32 921
351dd634 922 AliInfo(Form("%d", digits->GetEntriesFast())) ;
88cb7938 923 printf("\nevent %d", gAlice->GetEvNumber()) ;
924 printf("\n Number of entries in Digits list %d", digits->GetEntriesFast() ) ;
925
11f9c5ff 926
3bf72d32 927 if(strstr(option,"all")||strstr(option,"EMC")){
8cb3533f 928 //loop over digits
929 AliPHOSDigit * digit;
88cb7938 930 printf("\nEMC digits (with primaries):\n") ;
931 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
f898e0f3 932 Int_t maxEmc = geom->GetNModules()*geom->GetNCristalsInModule() ;
8cb3533f 933 Int_t index ;
a6eedfad 934 for (index = 0 ; (index < digits->GetEntriesFast()) &&
97e75f77 935 (static_cast<AliPHOSDigit *>(digits->At(index))->GetId() <= maxEmc) ; index++) {
7b7c1533 936 digit = (AliPHOSDigit * ) digits->At(index) ;
21cd0c07 937 if(digit->GetNprimary() == 0)
938 continue;
27a73a5d 939// printf("%6d %8d %6.5e %4d %2d :",
940// digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ; // YVK
941 printf("%6d %.4f %6.5e %4d %2d :",
942 digit->GetId(), digit->GetEnergy(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
8cb3533f 943 Int_t iprimary;
21cd0c07 944 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
88cb7938 945 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
21cd0c07 946 }
81d5f731 947 printf("\n") ;
21cd0c07 948 }
9688c1dd 949 }
3bf72d32 950
9688c1dd 951 if(strstr(option,"all")||strstr(option,"CPV")){
8cb3533f 952
9688c1dd 953 //loop over CPV digits
954 AliPHOSDigit * digit;
88cb7938 955 printf("\nCPV digits (with primaries):\n") ;
956 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
f898e0f3 957 Int_t maxEmc = geom->GetNModules()*geom->GetNCristalsInModule() ;
9688c1dd 958 Int_t index ;
a6eedfad 959 for (index = 0 ; index < digits->GetEntriesFast(); index++) {
9688c1dd 960 digit = (AliPHOSDigit * ) digits->At(index) ;
961 if(digit->GetId() > maxEmc){
81d5f731 962 printf("%6d %8d %4d %2d :",
11f9c5ff 963 digit->GetId(), digit->GetAmp(), digit->GetIndexInList(), digit->GetNprimary()) ;
9688c1dd 964 Int_t iprimary;
21cd0c07 965 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
88cb7938 966 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
21cd0c07 967 }
81d5f731 968 printf("\n") ;
21cd0c07 969 }
9688c1dd 970 }
8cb3533f 971 }
88cb7938 972
8cb3533f 973}
7b7c1533 974
9688c1dd 975//__________________________________________________________________
0bc3b8ed 976Float_t AliPHOSDigitizer::TimeOfNoise(void) const
9688c1dd 977{ // Calculates the time signal generated by noise
26a2ef9d 978 //PH Info("TimeOfNoise", "Change me") ;
04f0bda3 979 return gRandom->Rndm() * 1.28E-5;
9688c1dd 980}
7b7c1533 981
88cb7938 982//__________________________________________________________________
983void AliPHOSDigitizer::Unload()
984{
985
986 Int_t i ;
987 for(i = 1 ; i < fInput ; i++){
988 TString tempo(fEventNames[i]) ;
989 tempo += i ;
f898e0f3 990 AliRunLoader* rl = AliRunLoader::GetRunLoader(tempo) ;
97e75f77 991 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 992 phosLoader->UnloadSDigits() ;
88cb7938 993 }
994
f898e0f3 995 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 996 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 997 phosLoader->UnloadDigits() ;
88cb7938 998}
999
7b7c1533 1000//____________________________________________________________________________
90cceaf6 1001void AliPHOSDigitizer::WriteDigits()
7b7c1533 1002{
1003
1004 // Makes TreeD in the output file.
1005 // Check if branch already exists:
1006 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
1007 // already existing branches.
1008 // else creates branch with Digits, named "PHOS", title "...",
1009 // and branch "AliPHOSDigitizer", with the same title to keep all the parameters
1010 // and names of files, from which digits are made.
1011
f898e0f3 1012 AliRunLoader* rl = AliRunLoader::GetRunLoader(fEventFolderName) ;
97e75f77 1013 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
f898e0f3 1014
1015 const TClonesArray * digits = phosLoader->Digits() ;
1016 TTree * treeD = phosLoader->TreeD();
1017 if(!treeD){
1018 phosLoader->MakeTree("D");
1019 treeD = phosLoader->TreeD();
1020 }
1021
7b7c1533 1022 // -- create Digits branch
1023 Int_t bufferSize = 32000 ;
2524c56f 1024 TBranch * digitsBranch = treeD->Branch("PHOS","TClonesArray",&digits,bufferSize);
88cb7938 1025 digitsBranch->SetTitle(fEventFolderName);
1026 digitsBranch->Fill() ;
fbf811ec 1027
f898e0f3 1028 phosLoader->WriteDigits("OVERWRITE");
88cb7938 1029
1030 Unload() ;
b3690abb 1031
7b7c1533 1032}