Most PWG1 AddTask macros used in the pilot QA train were modified to use mgr->GetComm...
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALDigitizer.cxx
CommitLineData
61e0abb5 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//_________________________________________________________________________
ffa6d63b 19//
61e0abb5 20//////////////////////////////////////////////////////////////////////////////
ab6a174f 21// Class performs digitization of Summable digits from simulated data
ffa6d63b 22//
61e0abb5 23// In addition it performs mixing of summable digits from different events.
24//
25// For each event two branches are created in TreeD:
26// "EMCAL" - list of digits
27// "AliEMCALDigitizer" - AliEMCALDigitizer with all parameters used in digitization
28//
29// Note, that one cset title for new digits branch, and repeat digitization with
30// another set of parameters.
31//
32// Examples of use:
33// root[0] AliEMCALDigitizer * d = new AliEMCALDigitizer() ;
34// root[1] d->ExecuteTask()
35// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
36// //Digitizes SDigitis in all events found in file galice.root
37//
38// root[2] AliEMCALDigitizer * d1 = new AliEMCALDigitizer("galice1.root") ;
39// // Will read sdigits from galice1.root
40// root[3] d1->MixWith("galice2.root")
41// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
42// // Reads another portion of sdigits from galice2.root
43// root[3] d1->MixWith("galice3.root")
44// // Reads another portion of sdigits from galice3.root
45// root[4] d->ExecuteTask("deb timing")
46// // Reads SDigits from files galice1.root, galice2.root ....
47// // mixes them and stores produced Digits in file galice1.root
48// // deb - prints number of produced digits
49// // deb all - prints list of produced digits
50// // timing - prints time used for digitization
ffa6d63b 51////////////////////////////////////////////////////////////////////////////////////
61e0abb5 52//
ffa6d63b 53//*-- Author: Sahal Yacoob (LBL)
814ad4bf 54// based on : AliEMCALDigitizer
05a92d59 55// Modif:
56// August 2002 Yves Schutz: clone PHOS as closely as possible and intoduction
57// of new IO (à la PHOS)
1963b290 58// November 2003 Aleksei Pavlinov : adopted for Shish-Kebab geometry
59//_________________________________________________________________________________
61e0abb5 60
61// --- ROOT system ---
e939a978 62#include <TROOT.h>
63#include <TTree.h>
64#include <TSystem.h>
65#include <TBenchmark.h>
e939a978 66#include <TBrowser.h>
67#include <TObjectTable.h>
68#include <TRandom.h>
916f1e76 69#include <TF1.h>
21e7df44 70#include <cassert>
61e0abb5 71
72// --- AliRoot header files ---
b42d4197 73#include "AliLog.h"
e4dcc484 74#include "AliRun.h"
ea5f3389 75#include "AliRunDigitizer.h"
5dee926e 76#include "AliRunLoader.h"
53f1c378 77#include "AliCDBManager.h"
78#include "AliCDBEntry.h"
61e0abb5 79#include "AliEMCALDigit.h"
05a92d59 80#include "AliEMCAL.h"
5dee926e 81#include "AliEMCALLoader.h"
61e0abb5 82#include "AliEMCALDigitizer.h"
83#include "AliEMCALSDigitizer.h"
84#include "AliEMCALGeometry.h"
6b527f8f 85//#include "AliEMCALTick.h"
a435f763 86#include "AliEMCALCalibData.h"
33a52e55 87#include "AliEMCALSimParam.h"
916f1e76 88#include "AliEMCALRawDigit.h"
89
90namespace
91{
92 Double_t HeavisideTheta(Double_t x)
93 {
94 Double_t signal = 0.;
95
96 if (x > 0.) signal = 1.;
97
98 return signal;
99 }
100
101 Double_t AnalogFastORFunction(Double_t *x, Double_t *par)
102 {
103 Double_t v0 = par[0];
104 Double_t t0 = par[1];
105 Double_t tr = par[2];
106
107 Double_t R1 = 1000.;
108 Double_t C1 = 33e-12;
109 Double_t R2 = 1800;
110 Double_t C2 = 22e-12;
111
112 Double_t t = x[0];
113
114 return (((0.8*(-((TMath::Power(C1,2)*C2*TMath::Power(TMath::E(),(-t + t0)/(C1*R1))*
115 TMath::Power(R1,2)*R2)/(C1*R1 - C2*R2)) +
116 C1*C2*R1*R2*(1 - (C2*TMath::Power(TMath::E(),(-t + t0)/(C2*R2))*R2)/(-(C1*R1) + C2*R2)))*v0*
117 HeavisideTheta(t - t0))/tr
118 - (0.8*(C1*C2*R1*R2 -
119 (TMath::Power(C1,2)*C2*TMath::Power(TMath::E(),(-1.*t + t0 + 1.25*tr)/(C1*R1))*
120 TMath::Power(R1,2)*R2)/(C1*R1 - C2*R2) +
121 (C1*TMath::Power(C2,2)*TMath::Power(TMath::E(),(-1.*t + t0 + 1.25*tr)/(C2*R2))*
122 R1*TMath::Power(R2,2))/(C1*R1 - C2*R2))*v0*
123 HeavisideTheta(t - t0 - 1.25*tr))/tr)/(C2*R1));
124 }
125}
05a92d59 126
61e0abb5 127ClassImp(AliEMCALDigitizer)
128
129
130//____________________________________________________________________________
18a21c7c 131AliEMCALDigitizer::AliEMCALDigitizer()
132 : AliDigitizer("",""),
133 fDefaultInit(kTRUE),
134 fDigitsInRun(0),
135 fInit(0),
136 fInput(0),
137 fInputFileNames(0x0),
138 fEventNames(0x0),
139 fDigitThreshold(0),
140 fMeanPhotonElectron(0),
33a52e55 141// fPedestal(0), //Not used, remove?
142// fSlope(0), //Not used, remove?
18a21c7c 143 fPinNoise(0),
144 fTimeResolution(0),
33a52e55 145// fTimeThreshold(0), //Not used, remove?
146// fTimeSignalLength(0), //Not used, remove?
18a21c7c 147 fADCchannelEC(0),
148 fADCpedestalEC(0),
149 fNADCEC(0),
150 fEventFolderName(""),
151 fFirstEvent(0),
152 fLastEvent(0),
7ea6391b 153 fCalibData(0x0)
61e0abb5 154{
155 // ctor
88cb7938 156 InitParameters() ;
ab6a174f 157 fManager = 0 ; // We work in the standalone mode
839828a6 158}
61e0abb5 159
839828a6 160//____________________________________________________________________________
18a21c7c 161AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName)
162 : AliDigitizer("EMCAL"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName),
163 fDefaultInit(kFALSE),
164 fDigitsInRun(0),
165 fInit(0),
166 fInput(0),
167 fInputFileNames(0),
168 fEventNames(0),
169 fDigitThreshold(0),
170 fMeanPhotonElectron(0),
33a52e55 171// fPedestal(0),//Not used, remove?
172// fSlope(0), //Not used, remove?
18a21c7c 173 fPinNoise(0),
174 fTimeResolution(0),
33a52e55 175// fTimeThreshold(0), //Not used, remove?
176// fTimeSignalLength(0), //Not used, remove?
18a21c7c 177 fADCchannelEC(0),
178 fADCpedestalEC(0),
179 fNADCEC(0),
180 fEventFolderName(eventFolderName),
181 fFirstEvent(0),
182 fLastEvent(0),
7ea6391b 183 fCalibData(0x0)
839828a6 184{
05a92d59 185 // ctor
a9485c37 186 InitParameters() ;
88cb7938 187 Init() ;
ab6a174f 188 fManager = 0 ; // We work in the standalone mode
61e0abb5 189}
839828a6 190
61e0abb5 191//____________________________________________________________________________
18a21c7c 192AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
193 : AliDigitizer(d.GetName(),d.GetTitle()),
194 fDefaultInit(d.fDefaultInit),
195 fDigitsInRun(d.fDigitsInRun),
196 fInit(d.fInit),
197 fInput(d.fInput),
198 fInputFileNames(d.fInputFileNames),
199 fEventNames(d.fEventNames),
200 fDigitThreshold(d.fDigitThreshold),
201 fMeanPhotonElectron(d.fMeanPhotonElectron),
33a52e55 202// fPedestal(d.fPedestal), //Not used, remove?
203// fSlope(d.fSlope), //Not used, remove?
18a21c7c 204 fPinNoise(d.fPinNoise),
205 fTimeResolution(d.fTimeResolution),
33a52e55 206// fTimeThreshold(d.fTimeThreshold), //Not used, remove?
207// fTimeSignalLength(d.fTimeSignalLength), //Not used, remove?
18a21c7c 208 fADCchannelEC(d.fADCchannelEC),
209 fADCpedestalEC(d.fADCpedestalEC),
210 fNADCEC(d.fNADCEC),
211 fEventFolderName(d.fEventFolderName),
212 fFirstEvent(d.fFirstEvent),
213 fLastEvent(d.fLastEvent),
7ea6391b 214 fCalibData(d.fCalibData)
88cb7938 215{
216 // copyy ctor
88cb7938 217 }
218
219//____________________________________________________________________________
18a21c7c 220AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
221 : AliDigitizer(rd,"EMCAL"+AliConfig::Instance()->GetDigitizerTaskName()),
222 fDefaultInit(kFALSE),
223 fDigitsInRun(0),
224 fInit(0),
225 fInput(0),
226 fInputFileNames(0),
227 fEventNames(0),
da509d54 228 fDigitThreshold(0),
18a21c7c 229 fMeanPhotonElectron(0),
33a52e55 230// fPedestal(0), //Not used, remove?
231// fSlope(0.), //Not used, remove?
da509d54 232 fPinNoise(0.),
18a21c7c 233 fTimeResolution(0.),
33a52e55 234// fTimeThreshold(0), //Not used, remove?
235// fTimeSignalLength(0), //Not used, remove?
18a21c7c 236 fADCchannelEC(0),
237 fADCpedestalEC(0),
238 fNADCEC(0),
239 fEventFolderName(0),
240 fFirstEvent(0),
241 fLastEvent(0),
7ea6391b 242 fCalibData(0x0)
61e0abb5 243{
45fa49ca 244 // ctor Init() is called by RunDigitizer
88cb7938 245 fManager = rd ;
e0e18b6d 246 fEventFolderName = fManager->GetInputFolderName(0) ;
88cb7938 247 SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
05a92d59 248 InitParameters() ;
839828a6 249}
814ad4bf 250
839828a6 251//____________________________________________________________________________
252 AliEMCALDigitizer::~AliEMCALDigitizer()
253{
14ce0a6e 254 //dtor
33c3c91a 255 if (AliRunLoader::Instance()) {
5dee926e 256 AliLoader *emcalLoader=0;
33c3c91a 257 if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
5dee926e 258 emcalLoader->CleanDigitizer();
259 }
260 else
261 AliDebug(1," no runloader present");
f5f384f4 262 delete [] fInputFileNames ;
263 delete [] fEventNames ;
64942713 264
61e0abb5 265}
266
267//____________________________________________________________________________
09884213 268void AliEMCALDigitizer::Digitize(Int_t event)
05a92d59 269{
61e0abb5 270
271 // Makes the digitization of the collected summable digits
272 // for this it first creates the array of all EMCAL modules
ab6a174f 273 // filled with noise and after that adds contributions from
274 // SDigits. This design helps to avoid scanning over the
275 // list of digits to add contribution of any new SDigit.
276 //
277 // JLK 26-Jun-2008
278 // Note that SDigit energy info is stored as an amplitude, so we
279 // must call the Calibrate() method of the SDigitizer to convert it
280 // back to an energy in GeV before adding it to the Digit
281 //
1963b290 282 static int nEMC=0; //max number of digits possible
61e0abb5 283
33c3c91a 284 AliRunLoader *rl = AliRunLoader::Instance();
5dee926e 285 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
14ce0a6e 286 Int_t readEvent = event ;
1963b290 287 // fManager is data member from AliDigitizer
45fa49ca 288 if (fManager)
14ce0a6e 289 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ;
cf24bdc4 290 AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
14ce0a6e 291 readEvent, GetTitle(), fEventFolderName.Data())) ;
292 rl->GetEvent(readEvent);
5dee926e 293
294 TClonesArray * digits = emcalLoader->Digits() ;
ab6a174f 295 digits->Delete() ; //correct way to clear array when memory is
296 //allocated by objects stored in array
61e0abb5 297
e4dcc484 298 // Load Geometry
30bc5594 299 AliEMCALGeometry *geom = 0;
300 if (rl->GetAliRun()) {
301 AliEMCAL * emcal = (AliEMCAL*)rl->GetAliRun()->GetDetector("EMCAL");
302 geom = emcal->GetGeometry();
303 }
304 else
305 AliFatal("Could not get AliRun from runLoader");
e4dcc484 306
fe93d365 307 nEMC = geom->GetNCells();
308 AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s \n", nEMC, geom->GetName()));
309
88cb7938 310 Int_t absID ;
61e0abb5 311
88cb7938 312 digits->Expand(nEMC) ;
05a92d59 313
88cb7938 314 // get first the sdigitizer from the tasks list (must have same name as the digitizer)
5dee926e 315 if ( !emcalLoader->SDigitizer() )
316 emcalLoader->LoadSDigitizer();
317 AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer());
88cb7938 318
319 if ( !sDigitizer )
320 Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ;
321
322 //take all the inputs to add together and load the SDigits
323 TObjArray * sdigArray = new TObjArray(fInput) ;
5dee926e 324 sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
88cb7938 325 Int_t i ;
5dee926e 326
88cb7938 327 for(i = 1 ; i < fInput ; i++){
328 TString tempo(fEventNames[i]) ;
329 tempo += i ;
3880b0fb 330
331 AliRunLoader * rl2 = AliRunLoader::GetRunLoader(tempo) ;
332
333 if (rl2==0)
334 rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
335
45fa49ca 336 if (fManager)
14ce0a6e 337 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ;
338 Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ;
3880b0fb 339 rl2->LoadSDigits();
14ce0a6e 340 rl2->GetEvent(readEvent);
3880b0fb 341 AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
342 sdigArray->AddAt(emcalLoader2->SDigits(), i) ;
0c219753 343 }
5dee926e 344
d968cee0 345 //Find the first tower with signal
a9485c37 346 Int_t nextSig = nEMC + 1 ;
88cb7938 347 TClonesArray * sdigits ;
348 for(i = 0 ; i < fInput ; i++){
349 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
814ad4bf 350 if ( !sdigits->GetEntriesFast() )
351 continue ;
88cb7938 352 Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
814ad4bf 353 if(curNext < nextSig)
354 nextSig = curNext ;
cf24bdc4 355 AliDebug(1,Form("input %i : #sdigits %i \n",
356 i, sdigits->GetEntriesFast()));
814ad4bf 357 }
cf24bdc4 358 AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
61e0abb5 359
88cb7938 360 TArrayI index(fInput) ;
814ad4bf 361 index.Reset() ; //Set all indexes to zero
61e0abb5 362
05a92d59 363 AliEMCALDigit * digit ;
364 AliEMCALDigit * curSDigit ;
ffa6d63b 365
9517d886 366 // TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
ffa6d63b 367
5dee926e 368 //Put Noise contribution
d25f2c54 369 for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
ab6a174f 370 Float_t energy = 0 ;
a9485c37 371 // amplitude set to zero, noise will be added later
d25f2c54 372 new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0, TimeOfNoise() ); // absID-1->absID
814ad4bf 373 //look if we have to add signal?
d25f2c54 374 digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
88cb7938 375
814ad4bf 376 if(absID==nextSig){
54cbf5a6 377 //Add SDigits from all inputs
9517d886 378 // ticks->Clear() ;
379 //Int_t contrib = 0 ;
380
381 //Follow PHOS and comment out this timing model til a better one
382 //can be developed - JLK 28-Apr-2008
383
384 //Float_t a = digit->GetAmp() ;
385 //Float_t b = TMath::Abs( a /fTimeSignalLength) ;
88cb7938 386 //Mark the beginning of the signal
9517d886 387 //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);
fdebddeb 388 //Mark the end of the signal
9517d886 389 //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
390
391 // Calculate time as time of the largest digit
392 Float_t time = digit->GetTime() ;
ab6a174f 393 Float_t aTime= digit->GetAmp() ;
814ad4bf 394
88cb7938 395 // loop over input
396 for(i = 0; i< fInput ; i++){ //loop over (possible) merge sources
397 if(dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
398 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
814ad4bf 399 else
400 curSDigit = 0 ;
401 //May be several digits will contribute from the same input
fdebddeb 402 while(curSDigit && (curSDigit->GetId() == absID)){
814ad4bf 403 //Shift primary to separate primaries belonging different inputs
404 Int_t primaryoffset ;
405 if(fManager)
406 primaryoffset = fManager->GetMask(i) ;
407 else
408 primaryoffset = i ;
409 curSDigit->ShiftPrimary(primaryoffset) ;
9517d886 410
411 //Remove old timing model - JLK 28-April-2008
412 //a = curSDigit->GetAmp() ;
413 //b = a /fTimeSignalLength ;
414 //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime(),0, b);
415 //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
ab6a174f 416 if(curSDigit->GetAmp()>aTime) {
417 aTime = curSDigit->GetAmp();
9517d886 418 time = curSDigit->GetTime();
419 }
814ad4bf 420
ab6a174f 421 *digit = *digit + *curSDigit ; //adds amplitudes of each digit
814ad4bf 422
423 index[i]++ ;
88cb7938 424 if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
1963b290 425 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
814ad4bf 426 else
427 curSDigit = 0 ;
428 }
429 }
ab6a174f 430 //Here we convert the summed amplitude to an energy in GeV
431 energy = sDigitizer->Calibrate(digit->GetAmp()) ; // GeV
a9485c37 432 // add fluctuations for photo-electron creation
ab6a174f 433 energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
88cb7938 434
05a92d59 435 //calculate and set time
9517d886 436 //New timing model needed - JLK 28-April-2008
437 //Float_t time = FrontEdgeTime(ticks) ;
814ad4bf 438 digit->SetTime(time) ;
439
440 //Find next signal module
a9485c37 441 nextSig = nEMC + 1 ;
88cb7938 442 for(i = 0 ; i < fInput ; i++){
443 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
814ad4bf 444 Int_t curNext = nextSig ;
445 if(sdigits->GetEntriesFast() > index[i] ){
88cb7938 446 curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]))->GetId() ;
814ad4bf 447 }
448 if(curNext < nextSig) nextSig = curNext ;
449 }
450 }
a9485c37 451 // add the noise now
ab6a174f 452 energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
453 // JLK 26-June-2008
454 //Now digitize the energy according to the sDigitizer method,
455 //which merely converts the energy to an integer. Later we will
456 //check that the stored value matches our allowed dynamic ranges
457 digit->SetAmp(sDigitizer->Digitize(energy)) ;
458 AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
459 absID, energy, nextSig));
460 } // for(absID = 0; absID < nEMC; absID++)
814ad4bf 461
9517d886 462 //ticks->Delete() ;
463 //delete ticks ;
61e0abb5 464
ab6a174f 465 //JLK is it better to call Clear() here?
05a92d59 466 delete sdigArray ; //We should not delete its contents
61e0abb5 467
814ad4bf 468 //remove digits below thresholds
4354827d 469 // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
470 // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3
471 Float_t energy=0;
88cb7938 472 for(i = 0 ; i < nEMC ; i++){
473 digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
4354827d 474 //First get the energy in GeV units.
475 energy = sDigitizer->Calibrate(digit->GetAmp()) ;
476 //Then digitize using the calibration constants of the ocdb
477 Int_t ampADC = DigitizeEnergy(energy, digit->GetId()) ;
478 //if(ampADC>2)printf("Digit energy %f, amp %d, amp cal %d, threshold %d\n",energy,digit->GetAmp(),ampADC,fDigitThreshold);
479 if(ampADC < fDigitThreshold)
88cb7938 480 digits->RemoveAt(i) ;
481 else
814ad4bf 482 digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
a9485c37 483 }
61e0abb5 484
814ad4bf 485 digits->Compress() ;
61e0abb5 486
05a92d59 487 Int_t ndigits = digits->GetEntriesFast() ;
4354827d 488
ab6a174f 489 //JLK 26-June-2008
490 //After we have done the summing and digitizing to create the
491 //digits, now we want to calibrate the resulting amplitude to match
492 //the dynamic range of our real data.
05a92d59 493 for (i = 0 ; i < ndigits ; i++) {
494 digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
814ad4bf 495 digit->SetIndexInList(i) ;
1963b290 496 energy = sDigitizer->Calibrate(digit->GetAmp()) ;
ab6a174f 497 digit->SetAmp(DigitizeEnergy(energy, digit->GetId()) ) ;
61e0abb5 498 }
ab6a174f 499
814ad4bf 500}
61e0abb5 501
d62a891a 502// //_____________________________________________________________________
e4dcc484 503Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
814ad4bf 504{
ab6a174f 505 // JLK 26-June-2008
e4dcc484 506 // Returns digitized value of the energy in a cell absId
ab6a174f 507 // using the calibration constants stored in the OCDB
508 // or default values if no CalibData object is found.
509 // This effectively converts everything to match the dynamic range
510 // of the real data we will collect
511 //
53f1c378 512 // Load Geometry
513 const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
e4dcc484 514
515 if (geom==0)
d25f2c54 516 AliFatal("Did not get geometry from EMCALLoader");
e4dcc484 517
518 Int_t iSupMod = -1;
2bb3725c 519 Int_t nModule = -1;
e4dcc484 520 Int_t nIphi = -1;
521 Int_t nIeta = -1;
522 Int_t iphi = -1;
523 Int_t ieta = -1;
fdebddeb 524 Int_t channel = -999;
e4dcc484 525
2bb3725c 526 Bool_t bCell = geom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
e4dcc484 527 if(!bCell)
d25f2c54 528 Error("DigitizeEnergy","Wrong cell id number : AbsId %i ", AbsId) ;
2bb3725c 529 geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
d62a891a 530
53f1c378 531 if(fCalibData) {
532 fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
533 fADCchannelEC = fCalibData->GetADCchannel(iSupMod,ieta,iphi);
e4dcc484 534 }
5eb74a51 535
5fdfec03 536 channel = static_cast<Int_t> (TMath::Floor( (energy + fADCpedestalEC)/fADCchannelEC )) ;
5eb74a51 537
fdebddeb 538 if(channel > fNADCEC )
7d74eaca 539 channel = fNADCEC ;
814ad4bf 540 return channel ;
d62a891a 541
61e0abb5 542}
543
544//____________________________________________________________________________
05a92d59 545void AliEMCALDigitizer::Exec(Option_t *option)
546{
45fa49ca 547 // Steering method to process digitization for events
548 // in the range from fFirstEvent to fLastEvent.
549 // This range is optionally set by SetEventRange().
550 // if fLastEvent=-1, then process events until the end.
551 // by default fLastEvent = fFirstEvent (process only one event)
05a92d59 552
88cb7938 553 if (!fInit) { // to prevent overwrite existing file
554 Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
555 return ;
556 }
557
814ad4bf 558 if (strstr(option,"print")) {
b42d4197 559
88cb7938 560 Print();
814ad4bf 561 return ;
562 }
563
61e0abb5 564 if(strstr(option,"tim"))
565 gBenchmark->Start("EMCALDigitizer");
5dee926e 566
33c3c91a 567 AliRunLoader *rl = AliRunLoader::Instance();
5dee926e 568 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
569
5b4d2c50 570 // Post Digitizer to the white board
5dee926e 571 emcalLoader->PostDigitizer(this) ;
5b4d2c50 572
30bc5594 573 if (fLastEvent == -1) {
5dee926e 574 fLastEvent = rl->GetNumberOfEvents() - 1 ;
30bc5594 575 }
396a348e 576 else if (fManager)
1963b290 577 fLastEvent = fFirstEvent ; // what is this ??
396a348e 578
45fa49ca 579 Int_t nEvents = fLastEvent - fFirstEvent + 1;
cf24bdc4 580 Int_t ievent;
581
916f1e76 582 TClonesArray* digitsTRG = new TClonesArray("AliEMCALRawDigit", 32 * 96);
583 TClonesArray* digitsTMP = new TClonesArray("AliEMCALDigit", 32 * 96);
5dee926e 584 rl->LoadSDigits("EMCAL");
cf24bdc4 585 for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
64942713 586
5dee926e 587 rl->GetEvent(ievent);
05a92d59 588
814ad4bf 589 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
88cb7938 590
9e5d2067 591 WriteDigits() ;
916f1e76 592
593 //Trigger Digits
594 //-------------------------------------
595 Digits2FastOR(digitsTMP, digitsTRG);
596
597 WriteDigits(digitsTRG);
598
599 emcalLoader->WriteDigits( "OVERWRITE");
600 emcalLoader->WriteDigitizer("OVERWRITE");
601
602 Unload();
603
604 digitsTRG->Clear();
605 digitsTMP->Clear();
606 //-------------------------------------
88cb7938 607
61e0abb5 608 if(strstr(option,"deb"))
609 PrintDigits(option);
1963b290 610 if(strstr(option,"table")) gObjectTable->Print();
88cb7938 611
814ad4bf 612 //increment the total number of Digits per run
5dee926e 613 fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;
61e0abb5 614 }
64942713 615
5dee926e 616 emcalLoader->CleanDigitizer() ;
5b4d2c50 617
61e0abb5 618 if(strstr(option,"tim")){
619 gBenchmark->Stop("EMCALDigitizer");
b42d4197 620 AliInfo(Form("Exec: took %f seconds for Digitizing %f seconds per event",
621 gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nEvents )) ;
88cb7938 622 }
61e0abb5 623}
624
05a92d59 625//____________________________________________________________________________
916f1e76 626void AliEMCALDigitizer::Digits2FastOR(TClonesArray* digitsTMP, TClonesArray* digitsTRG)
627{
628 // FEE digits afterburner to produce TRG digits
629 // we are only interested in the FEE digit deposited energy
630 // to be converted later into a voltage value
631
632 // push the FEE digit to its associated FastOR (numbered from 0:95)
633 // TRU is in charge of summing module digits
634
635 AliRunLoader *runLoader = AliRunLoader::Instance();
636
637 AliRun* run = runLoader->GetAliRun();
638
639 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
640
641 AliEMCALGeometry* geom = dynamic_cast<AliEMCAL*>(run->GetDetector("EMCAL"))->GetGeometry();
642
643 // build FOR from simulated digits
644 // and xfer to the corresponding TRU input (mapping)
645
646 TClonesArray* digits = emcalLoader->Digits();
647
648 TIter NextDigit(digits);
649 while (AliEMCALDigit* digit = (AliEMCALDigit*)NextDigit())
650 {
651 Int_t id = digit->GetId();
652
653 Int_t iSupMod, nModule, nIphi, nIeta, iphi, ieta, iphim, ietam;
654
655 geom->GetCellIndex( id, iSupMod, nModule, nIphi, nIeta );
656 geom->GetModulePhiEtaIndexInSModule( iSupMod, nModule, iphim, ietam );
657 geom->GetCellPhiEtaIndexInSModule( iSupMod, nModule, nIphi, nIeta, iphi, ieta);
658
659 // identify to which TRU this FEE digit belong
52b045b9 660 //Int_t itru = (iSupMod < 11) ? iphim / 4 + 3 * iSupMod : 31;
661 Int_t itru = -1;
662 if (iSupMod < 11)
663 itru = (iSupMod % 2) ? (2 - int(iphim / 4)) + 3 * iSupMod : iphim / 4 + 3 * iSupMod;
664 else
665 itru = 31;
916f1e76 666
667 //---------
668 //
669 // FIXME: bad numbering solution to deal w/ the last 2 SM which have only 1 TRU each
670 // using the AliEMCALGeometry official numbering
671 // only 1 TRU/SM in SM 10 & SM 11
672 //
673 //---------
674 if ((itru == 31 && iphim < 2) || (itru == 30 && iphim > 5)) continue;
675
676 // to be compliant with %4 per TRU
677 if (itru == 31) iphim -= 2;
678
679 Int_t trgid;
680 Bool_t isOK = geom->GetAbsFastORIndexFromPositionInTRU(itru, ietam, iphim % 4, trgid);
681
682 AliDebug(2,Form("trigger digit id: %d itru: %d isOK: %d\n",trgid,itru,isOK));
683
684 if (isOK)
685 {
686 AliEMCALDigit* d = static_cast<AliEMCALDigit*>(digitsTMP->At(trgid));
687
688 if (!d)
689 {
690 new((*digitsTMP)[trgid]) AliEMCALDigit(*digit);
691 d = (AliEMCALDigit*)digitsTMP->At(trgid);
692 d->SetId(trgid);
693 }
694 else
695 {
696 *d = *d + *digit;
697 }
698 }
699 }
700
701 Int_t nSamples = 32;
da509d54 702 Int_t *timeSamples = new Int_t[nSamples];
916f1e76 703
704 NextDigit = TIter(digitsTMP);
705 while (AliEMCALDigit* digit = (AliEMCALDigit*)NextDigit())
706 {
707 if (digit)
708 {
709 Int_t id = digit->GetId();
710 Float_t time = digit->GetTime();
711
712 Double_t depositedEnergy = 0.;
713 for (Int_t j = 1; j <= digit->GetNprimary(); j++) depositedEnergy += digit->GetDEPrimary(j);
714
715 // FIXME: Check digit time!
716 if (depositedEnergy)
717 {
718 DigitalFastOR(time, depositedEnergy, timeSamples, nSamples);
719
720 for (Int_t j=0;j<nSamples;j++)
721 {
722 timeSamples[j] = ((j << 12) & 0xFF000) | (timeSamples[j] & 0xFFF);
723 }
724
725 new((*digitsTRG)[digitsTRG->GetEntriesFast()]) AliEMCALRawDigit(id, timeSamples, nSamples);
726 }
727 }
728 }
729}
730
731//____________________________________________________________________________
732void AliEMCALDigitizer::DigitalFastOR( Double_t time, Double_t dE, Int_t timeSamples[], Int_t nSamples )
733{
734 // parameters:
735 // id: 0..95
736 const Int_t reso = 11; // 11-bit resolution ADC
737 const Double_t vFSR = 1; // Full scale input voltage range
738 const Double_t Ne = 125; // signal of the APD per MeV of energy deposit in a tower: 125 photo-e-/MeV @ M=30
739 const Double_t vA = .136e-6; // CSP output range: 0.136uV/e-
740 const Double_t rise = 40e-9; // rise time (10-90%) of the FastOR signal before shaping
741
742 const Double_t kTimeBinWidth = 25E-9; // sampling frequency (40MHz)
743
744 Double_t vV = 1000. * dE * Ne * vA; // GeV 2 MeV
745
746 TF1 signalF("signal", AnalogFastORFunction, 0, nSamples * kTimeBinWidth, 3);
747 signalF.SetParameter( 0, vV );
748 signalF.SetParameter( 1, time ); // FIXME: when does the signal arrive? Might account for cable lengths
749 signalF.SetParameter( 2, rise );
750
751 for (Int_t iTime=0; iTime<nSamples; iTime++)
752 {
753 // FIXME: add noise (probably not simply Gaussian) according to DA measurements
754 // probably plan an access to OCDB
755
756 timeSamples[iTime] = int((TMath::Power(2, reso) / vFSR) * signalF.Eval(iTime * kTimeBinWidth) + 0.5);
757 }
758}
759
760
761//____________________________________________________________________________
33a52e55 762//Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks)
763//{
764// // Returns the shortest time among all time ticks
765//
766// ticks->Sort() ; //Sort in accordance with times of ticks
767// TIter it(ticks) ;
768// AliEMCALTick * ctick = (AliEMCALTick *) it.Next() ;
769// Float_t time = ctick->CrossingTime(fTimeThreshold) ;
770//
771// AliEMCALTick * t ;
772// while((t=(AliEMCALTick*) it.Next())){
773// if(t->GetTime() < time) //This tick starts before crossing
774// *ctick+=*t ;
775// else
776// return time ;
777//
778// time = ctick->CrossingTime(fTimeThreshold) ;
779// }
780// return time ;
781//}
782//
05a92d59 783
784//____________________________________________________________________________
785Bool_t AliEMCALDigitizer::Init()
786{
787 // Makes all memory allocations
88cb7938 788 fInit = kTRUE ;
33c3c91a 789 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
5dee926e 790
791 if ( emcalLoader == 0 ) {
792 Fatal("Init", "Could not obtain the AliEMCALLoader");
05a92d59 793 return kFALSE;
794 }
05a92d59 795
45fa49ca 796 fFirstEvent = 0 ;
797 fLastEvent = fFirstEvent ;
798
88cb7938 799 if(fManager)
800 fInput = fManager->GetNinputs() ;
801 else
802 fInput = 1 ;
803
804 fInputFileNames = new TString[fInput] ;
805 fEventNames = new TString[fInput] ;
806 fInputFileNames[0] = GetTitle() ;
807 fEventNames[0] = fEventFolderName.Data() ;
808 Int_t index ;
809 for (index = 1 ; index < fInput ; index++) {
810 fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0);
811 TString tempo = fManager->GetInputFolderName(index) ;
812 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager
05a92d59 813 }
814
88cb7938 815 //to prevent cleaning of this object while GetEvent is called
5dee926e 816 emcalLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
e52475ed 817
53f1c378 818 //Calibration instance
819 fCalibData = emcalLoader->CalibData();
88cb7938 820 return fInit ;
05a92d59 821}
822
823//____________________________________________________________________________
824void AliEMCALDigitizer::InitParameters()
14ce0a6e 825{
29b5d492 826 // Parameter initialization for digitizer
6569f329 827
828 // Get the parameters from the OCDB via the loader
829 AliRunLoader *rl = AliRunLoader::Instance();
830 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
831 AliEMCALSimParam * simParam = 0x0;
832 if(emcalLoader) simParam = emcalLoader->SimulationParameters();
833
834 if(!simParam){
835 simParam = AliEMCALSimParam::GetInstance();
836 AliWarning("Simulation Parameters not available in OCDB?");
837 }
838
839 fMeanPhotonElectron = simParam->GetMeanPhotonElectron();//4400; // electrons per GeV
840 fPinNoise = simParam->GetPinNoise();//0.012; // pin noise in GeV from analysis test beam data
33a52e55 841 if (fPinNoise < 0.0001 )
88cb7938 842 Warning("InitParameters", "No noise added\n") ;
6569f329 843 fDigitThreshold = simParam->GetDigitThreshold(); //fPinNoise * 3; // 3 * sigma
844 fTimeResolution = simParam->GetTimeResolution(); //0.6e-9 ; // 600 psc
05a92d59 845
97075cd8 846 // These defaults are normally not used.
847 // Values are read from calibration database instead
33a52e55 848 fADCchannelEC = 0.0153; // Update 24 Apr 2007: 250./16/1024 - width of one ADC channel in GeV
849 fADCpedestalEC = 0.0 ; // GeV
850
6569f329 851 fNADCEC = simParam->GetNADCEC();//(Int_t) TMath::Power(2,16) ; // number of channels in Tower ADC - 65536
33a52e55 852
853 AliDebug(2,Form("Mean Photon Electron %d, Noise %f, E Threshold %f,Time Resolution %g,NADCEC %d",
854 fMeanPhotonElectron,fPinNoise,fDigitThreshold,fTimeResolution,fNADCEC));
a9485c37 855
33a52e55 856 // Not used anymore, remove?
857 // fTimeSignalLength = 1.0e-9 ;
858 // fTimeThreshold = 0.001*10000000 ; // Means 1 MeV in terms of SDigits amplitude ??
ab6a174f 859
05a92d59 860}
61e0abb5 861
61e0abb5 862//__________________________________________________________________
09884213 863void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
05a92d59 864{
865 // Allows to produce digits by superimposing background and signal event.
61e0abb5 866 // It is assumed, that headers file with SIGNAL events is opened in
05a92d59 867 // the constructor.
868 // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed
869 // Thus we avoid writing (changing) huge and expensive
61e0abb5 870 // backgound files: all output will be writen into SIGNAL, i.e.
871 // opened in constructor file.
872 //
05a92d59 873 // One can open as many files to mix with as one needs.
874 // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
875 // can be mixed.
61e0abb5 876
05a92d59 877 if( strcmp(GetName(), "") == 0 )
61e0abb5 878 Init() ;
814ad4bf 879
05a92d59 880 if(fManager){
9859bfc0 881 Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
61e0abb5 882 return ;
05a92d59 883 }
88cb7938 884 // looking for file which contains AliRun
885 if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
886 Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
887 return ;
61e0abb5 888 }
88cb7938 889 // looking for the file which contains SDigits
33c3c91a 890 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
5dee926e 891 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
e191bb57 892 if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
88cb7938 893 fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
894 if ( (gSystem->AccessPathName(fileName)) ) {
895 Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
896 return ;
814ad4bf 897 }
88cb7938 898 // need to increase the arrays
30bc5594 899 // MvL: This code only works when fInput == 1, I think.
88cb7938 900 TString tempo = fInputFileNames[fInput-1] ;
901 delete [] fInputFileNames ;
902 fInputFileNames = new TString[fInput+1] ;
903 fInputFileNames[fInput-1] = tempo ;
904
905 tempo = fEventNames[fInput-1] ;
906 delete [] fEventNames ;
907 fEventNames = new TString[fInput+1] ;
908 fEventNames[fInput-1] = tempo ;
909
910 fInputFileNames[fInput] = alirunFileName ;
911 fEventNames[fInput] = eventFolderName ;
912 fInput++ ;
913}
1963b290 914
fe93d365 915//__________________________________________________________________
1963b290 916void AliEMCALDigitizer::Print1(Option_t * option)
917{ // 19-nov-04 - just for convinience
918 Print();
919 PrintDigits(option);
920}
921
61e0abb5 922//__________________________________________________________________
eb0b1051 923void AliEMCALDigitizer::Print(Option_t*)const
88cb7938 924{
925 // Print Digitizer's parameters
fdebddeb 926 printf("Print: \n------------------- %s -------------", GetName() ) ;
88cb7938 927 if( strcmp(fEventFolderName.Data(), "") != 0 ){
928 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
929
930 Int_t nStreams ;
931 if (fManager)
932 nStreams = GetNInputStreams() ;
933 else
934 nStreams = fInput ;
935
936 Int_t index = 0 ;
5dee926e 937
938 AliRunLoader *rl=0;
939
88cb7938 940 for (index = 0 ; index < nStreams ; index++) {
941 TString tempo(fEventNames[index]) ;
942 tempo += index ;
5dee926e 943 if ((rl = AliRunLoader::GetRunLoader(tempo)) == 0)
944 rl = AliRunLoader::Open(fInputFileNames[index], tempo) ;
945 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
946 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
e191bb57 947 if ( fEventNames[index] != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
88cb7938 948 fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index] + ".root" ;
949 printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ;
950 }
5dee926e 951
33c3c91a 952 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
5dee926e 953
954 printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
88cb7938 955
956 printf("\nWith following parameters:\n") ;
957
958 printf(" Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
4354827d 959 printf(" Threshold in Tower (fDigitThreshold) = %d\n", fDigitThreshold) ;
88cb7938 960 printf("---------------------------------------------------\n") ;
ea5f3389 961 }
962 else
fdebddeb 963 printf("Print: AliEMCALDigitizer not initialized") ;
61e0abb5 964}
814ad4bf 965
61e0abb5 966//__________________________________________________________________
14ce0a6e 967void AliEMCALDigitizer::PrintDigits(Option_t * option)
968{
969 //utility method for printing digit information
970
33c3c91a 971 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
5dee926e 972 TClonesArray * digits = emcalLoader->Digits() ;
973 TClonesArray * sdigits = emcalLoader->SDigits() ;
88cb7938 974
1963b290 975 printf("\n #Digits: %d : sdigits %d ", digits->GetEntriesFast(), sdigits->GetEntriesFast()) ;
5dee926e 976 printf("\n event %d", emcalLoader->GetRunLoader()->GetEventNumber());
88cb7938 977
978 if(strstr(option,"all")){
61e0abb5 979 //loop over digits
980 AliEMCALDigit * digit;
88cb7938 981 printf("\nEMC digits (with primaries):\n") ;
982 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
61e0abb5 983 Int_t index ;
88cb7938 984 for (index = 0 ; index < digits->GetEntries() ; index++) {
985 digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
986 printf("\n%6d %8d %6.5e %4d %2d : ",
11f9c5ff 987 digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
61e0abb5 988 Int_t iprimary;
9859bfc0 989 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
88cb7938 990 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
9859bfc0 991 }
992 }
61e0abb5 993 }
1963b290 994 printf("\n");
61e0abb5 995}
05a92d59 996
997//__________________________________________________________________
998Float_t AliEMCALDigitizer::TimeOfNoise(void)
04f0bda3 999{
1000 // Calculates the time signal generated by noise
26a2ef9d 1001 //PH Info("TimeOfNoise", "Change me") ;
04f0bda3 1002 return gRandom->Rndm() * 1.28E-5;
05a92d59 1003}
1004
88cb7938 1005//__________________________________________________________________
1006void AliEMCALDigitizer::Unload()
1007{
fdebddeb 1008 // Unloads the SDigits and Digits
5dee926e 1009 AliRunLoader *rl=0;
1010
88cb7938 1011 Int_t i ;
1012 for(i = 1 ; i < fInput ; i++){
1013 TString tempo(fEventNames[i]) ;
5dee926e 1014 tempo += i;
1015 if ((rl = AliRunLoader::GetRunLoader(tempo)))
1016 rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ;
88cb7938 1017 }
33c3c91a 1018 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
5dee926e 1019 emcalLoader->UnloadDigits() ;
88cb7938 1020}
1021
814ad4bf 1022//_________________________________________________________________________________________
9e5d2067 1023void AliEMCALDigitizer::WriteDigits()
814ad4bf 1024{
61e0abb5 1025
814ad4bf 1026 // Makes TreeD in the output file.
1027 // Check if branch already exists:
1028 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
1029 // already existing branches.
1030 // else creates branch with Digits, named "EMCAL", title "...",
1031 // and branch "AliEMCALDigitizer", with the same title to keep all the parameters
1032 // and names of files, from which digits are made.
61e0abb5 1033
33c3c91a 1034 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
cf24bdc4 1035
5dee926e 1036 const TClonesArray * digits = emcalLoader->Digits() ;
1037 TTree * treeD = emcalLoader->TreeD();
1038 if ( !treeD ) {
1039 emcalLoader->MakeDigitsContainer();
1040 treeD = emcalLoader->TreeD();
1041 }
88cb7938 1042
1043 // -- create Digits branch
1044 Int_t bufferSize = 32000 ;
5dee926e 1045 TBranch * digitsBranch = 0;
30bc5594 1046 if ((digitsBranch = treeD->GetBranch("EMCAL"))) {
5dee926e 1047 digitsBranch->SetAddress(&digits);
30bc5594 1048 AliWarning("Digits Branch already exists. Not all digits will be visible");
1049 }
5dee926e 1050 else
1051 treeD->Branch("EMCAL","TClonesArray",&digits,bufferSize);
1052 //digitsBranch->SetTitle(fEventFolderName);
1053 treeD->Fill() ;
916f1e76 1054/*
5dee926e 1055 emcalLoader->WriteDigits("OVERWRITE");
1056 emcalLoader->WriteDigitizer("OVERWRITE");
88cb7938 1057
1058 Unload() ;
916f1e76 1059*/
1060}
88cb7938 1061
916f1e76 1062//__________________________________________________________________
1063void AliEMCALDigitizer::WriteDigits(TClonesArray* digits, const char* branchName)
1064{
1065 //
1066 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
1067
1068 TTree* treeD = emcalLoader->TreeD();
1069 if (!treeD)
1070 {
1071 emcalLoader->MakeDigitsContainer();
1072 treeD = emcalLoader->TreeD();
1073 }
1074
1075 // -- create Digits branch
1076 Int_t bufferSize = 32000;
1077
1078 if (TBranch* triggerBranch = treeD->GetBranch(branchName))
1079 {
1080 triggerBranch->SetAddress(&digits);
1081 }
1082 else
1083 {
1084 treeD->Branch(branchName,"TClonesArray",&digits,bufferSize);
1085 }
1086
1087 treeD->Fill();
814ad4bf 1088}
61e0abb5 1089
fe93d365 1090//__________________________________________________________________
1963b290 1091void AliEMCALDigitizer::Browse(TBrowser* b)
1092{
1963b290 1093 TTask::Browse(b);
1094}