1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //_________________________________________________________________________
20 //////////////////////////////////////////////////////////////////////////////
21 // Class performs digitization of Summable digits
23 // In addition it performs mixing of summable digits from different events.
25 // For each event two branches are created in TreeD:
26 // "EMCAL" - list of digits
27 // "AliEMCALDigitizer" - AliEMCALDigitizer with all parameters used in digitization
29 // Note, that one cset title for new digits branch, and repeat digitization with
30 // another set of parameters.
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
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
51 ////////////////////////////////////////////////////////////////////////////////////
53 //*-- Author: Sahal Yacoob (LBL)
54 // based on : AliEMCALDigitizer
56 // August 2002 Yves Schutz: clone PHOS as closely as possible and intoduction
57 // of new IO (à la PHOS)
58 // November 2003 Aleksei Pavlinov : adopted for Shish-Kebab geometry
59 //_________________________________________________________________________________
61 // --- ROOT system ---
65 #include <TBenchmark.h>
69 #include <TObjectTable.h>
72 // --- AliRoot header files ---
75 #include "AliRunDigitizer.h"
76 #include "AliRunLoader.h"
77 #include "AliCDBManager.h"
78 #include "AliCDBEntry.h"
79 #include "AliEMCALDigit.h"
81 #include "AliEMCALLoader.h"
82 #include "AliEMCALDigitizer.h"
83 #include "AliEMCALSDigitizer.h"
84 #include "AliEMCALGeometry.h"
85 #include "AliEMCALTick.h"
86 #include "AliEMCALHistoUtilities.h"
88 ClassImp(AliEMCALDigitizer)
91 //____________________________________________________________________________
92 AliEMCALDigitizer::AliEMCALDigitizer()
93 : AliDigitizer("",""),
101 fMeanPhotonElectron(0),
107 fTimeSignalLength(0),
111 fEventFolderName(""),
115 fHists(0),fCalibData(0x0)
119 fManager = 0 ; // We work in the standalong mode
122 //____________________________________________________________________________
123 AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName)
124 : AliDigitizer("EMCAL"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName),
125 fDefaultInit(kFALSE),
132 fMeanPhotonElectron(0),
138 fTimeSignalLength(0),
142 fEventFolderName(eventFolderName),
151 fManager = 0 ; // We work in the standalong mode
154 //____________________________________________________________________________
155 AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
156 : AliDigitizer(d.GetName(),d.GetTitle()),
157 fDefaultInit(d.fDefaultInit),
158 fDigitsInRun(d.fDigitsInRun),
161 fInputFileNames(d.fInputFileNames),
162 fEventNames(d.fEventNames),
163 fDigitThreshold(d.fDigitThreshold),
164 fMeanPhotonElectron(d.fMeanPhotonElectron),
165 fPedestal(d.fPedestal),
167 fPinNoise(d.fPinNoise),
168 fTimeResolution(d.fTimeResolution),
169 fTimeThreshold(d.fTimeThreshold),
170 fTimeSignalLength(d.fTimeSignalLength),
171 fADCchannelEC(d.fADCchannelEC),
172 fADCpedestalEC(d.fADCpedestalEC),
174 fEventFolderName(d.fEventFolderName),
175 fFirstEvent(d.fFirstEvent),
176 fLastEvent(d.fLastEvent),
177 fControlHists(d.fControlHists),
178 fHists(d.fHists),fCalibData(d.fCalibData)
183 //____________________________________________________________________________
184 AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
185 : AliDigitizer(rd,"EMCAL"+AliConfig::Instance()->GetDigitizerTaskName()),
186 fDefaultInit(kFALSE),
193 fMeanPhotonElectron(0),
199 fTimeSignalLength(0),
209 // ctor Init() is called by RunDigitizer
211 fEventFolderName = fManager->GetInputFolderName(0) ;
212 SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
216 //____________________________________________________________________________
217 AliEMCALDigitizer::~AliEMCALDigitizer()
220 if (AliRunLoader::GetRunLoader()) {
221 AliLoader *emcalLoader=0;
222 if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
223 emcalLoader->CleanDigitizer();
226 AliDebug(1," no runloader present");
227 delete [] fInputFileNames ;
228 delete [] fEventNames ;
230 if(fHists) delete fHists;
233 //____________________________________________________________________________
234 void AliEMCALDigitizer::Digitize(Int_t event)
237 // Makes the digitization of the collected summable digits
238 // for this it first creates the array of all EMCAL modules
239 // filled with noise (different for EMC, CPV and PPSD) and
240 // after that adds contributions from SDigits. This design
241 // helps to avoid scanning over the list of digits to add
242 // contribution of any new SDigit.
243 static int isTrd1Geom = -1; // -1 - mean undefined
244 static int nEMC=0; //max number of digits possible
246 AliRunLoader *rl = AliRunLoader::GetRunLoader();
247 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
248 Int_t readEvent = event ;
249 // fManager is data member from AliDigitizer
251 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ;
252 AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
253 readEvent, GetTitle(), fEventFolderName.Data())) ;
254 rl->GetEvent(readEvent);
256 TClonesArray * digits = emcalLoader->Digits() ;
260 // const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
262 AliRun * gAlice = rl->GetAliRun();
263 AliEMCAL * emcal = (AliEMCAL*)gAlice->GetDetector("EMCAL");
264 AliEMCALGeometry * geom = emcal->GetGeometry();
267 AliInfo(Form(" get Geometry %s : %s ", geom->GetName(),geom->GetTitle()));
268 TString ng(geom->GetName());
270 if(ng.Contains("SHISH") && ng.Contains("TRD1")) isTrd1Geom = 1;
272 if(isTrd1Geom == 0) nEMC = geom->GetNPhi()*geom->GetNZ();
273 else nEMC = geom->GetNCells();
274 AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s | isTrd1Geom %i\n", nEMC, geom->GetName(), isTrd1Geom));
278 digits->Expand(nEMC) ;
280 // get first the sdigitizer from the tasks list (must have same name as the digitizer)
281 if ( !emcalLoader->SDigitizer() )
282 emcalLoader->LoadSDigitizer();
283 AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer());
286 Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ;
288 //take all the inputs to add together and load the SDigits
289 TObjArray * sdigArray = new TObjArray(fInput) ;
290 sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
293 for(i = 1 ; i < fInput ; i++){
294 TString tempo(fEventNames[i]) ;
297 AliRunLoader * rl2 = AliRunLoader::GetRunLoader(tempo) ;
300 rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
303 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ;
304 Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ;
306 rl2->GetEvent(readEvent);
307 AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
308 sdigArray->AddAt(emcalLoader2->SDigits(), i) ;
311 //Find the first tower with signal
312 Int_t nextSig = nEMC + 1 ;
313 TClonesArray * sdigits ;
314 for(i = 0 ; i < fInput ; i++){
315 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
316 if ( !sdigits->GetEntriesFast() )
318 Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
319 if(curNext < nextSig)
321 AliDebug(1,Form("input %i : #sdigits %i \n",
322 i, sdigits->GetEntriesFast()));
324 AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
326 TArrayI index(fInput) ;
327 index.Reset() ; //Set all indexes to zero
329 AliEMCALDigit * digit ;
330 AliEMCALDigit * curSDigit ;
332 TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
334 //Put Noise contribution
335 for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
337 // amplitude set to zero, noise will be added later
338 new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0, TimeOfNoise() ); // absID-1->absID
339 //look if we have to add signal?
340 digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
343 //Add SDigits from all inputs
346 Float_t a = digit->GetAmp() ;
347 Float_t b = TMath::Abs( a /fTimeSignalLength) ;
348 //Mark the beginning of the signal
349 new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);
350 //Mark the end of the signal
351 new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
354 for(i = 0; i< fInput ; i++){ //loop over (possible) merge sources
355 if(dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
356 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
359 //May be several digits will contribute from the same input
360 while(curSDigit && (curSDigit->GetId() == absID)){
361 //Shift primary to separate primaries belonging different inputs
362 Int_t primaryoffset ;
364 primaryoffset = fManager->GetMask(i) ;
367 curSDigit->ShiftPrimary(primaryoffset) ;
369 a = curSDigit->GetAmp() ;
370 b = a /fTimeSignalLength ;
371 new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime(),0, b);
372 new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
374 *digit = *digit + *curSDigit ; //add energies
377 if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
378 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
383 // add fluctuations for photo-electron creation
384 amp = sDigitizer->Calibrate(digit->GetAmp()) ; // GeV
385 amp *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
387 //calculate and set time
388 Float_t time = FrontEdgeTime(ticks) ;
389 digit->SetTime(time) ;
391 //Find next signal module
393 for(i = 0 ; i < fInput ; i++){
394 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
395 Int_t curNext = nextSig ;
396 if(sdigits->GetEntriesFast() > index[i] ){
397 curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]))->GetId() ;
399 if(curNext < nextSig) nextSig = curNext ;
403 amp += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
404 digit->SetAmp(sDigitizer->Digitize(amp)) ;
405 AliDebug(10,Form(" absID %5i amp %f nextSig %5i\n",
406 absID, amp, nextSig));
407 } // for(absID = 1; absID <= nEMC; absID++)
412 delete sdigArray ; //We should not delete its contents
414 //remove digits below thresholds
415 for(i = 0 ; i < nEMC ; i++){
416 digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
417 Float_t threshold = fDigitThreshold ;
418 if(sDigitizer->Calibrate( digit->GetAmp() ) < threshold)
419 digits->RemoveAt(i) ;
421 digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
426 Int_t ndigits = digits->GetEntriesFast() ;
427 digits->Expand(ndigits) ;
429 //Set indexes in list of digits and fill hists.
430 AliEMCALHistoUtilities::FillH1(fHists, 0, Double_t(ndigits));
431 Float_t energy=0., esum=0.;
432 for (i = 0 ; i < ndigits ; i++) {
433 digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
434 digit->SetIndexInList(i) ;
435 energy = sDigitizer->Calibrate(digit->GetAmp()) ;
437 digit->SetAmp(DigitizeEnergy(energy, digit->GetId()) ) ; // for what ??
438 AliEMCALHistoUtilities::FillH1(fHists, 2, double(digit->GetAmp()));
439 AliEMCALHistoUtilities::FillH1(fHists, 3, double(energy));
440 AliEMCALHistoUtilities::FillH1(fHists, 4, double(digit->GetId()));
441 // if(digit->GetId() == nEMC) {
442 // printf(" i %i \n", i );
447 AliEMCALHistoUtilities::FillH1(fHists, 1, esum);
450 // //_____________________________________________________________________
451 Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
453 // Returns digitized value of the energy in a cell absId
456 const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
459 AliFatal("Did not get geometry from EMCALLoader");
467 Int_t channel = -999;
469 Bool_t bCell = geom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
471 Error("DigitizeEnergy","Wrong cell id number : AbsId %i ", AbsId) ;
472 geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
475 fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
476 fADCchannelEC = fCalibData->GetADCchannel(iSupMod,ieta,iphi);
479 channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalEC)/fADCchannelEC )) ;
481 if(channel > fNADCEC )
487 //____________________________________________________________________________
488 void AliEMCALDigitizer::Exec(Option_t *option)
490 // Steering method to process digitization for events
491 // in the range from fFirstEvent to fLastEvent.
492 // This range is optionally set by SetEventRange().
493 // if fLastEvent=-1, then process events until the end.
494 // by default fLastEvent = fFirstEvent (process only one event)
496 if (!fInit) { // to prevent overwrite existing file
497 Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
501 if (strstr(option,"print")) {
507 if(strstr(option,"tim"))
508 gBenchmark->Start("EMCALDigitizer");
510 AliRunLoader *rl = AliRunLoader::GetRunLoader();
511 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
513 // Post Digitizer to the white board
514 emcalLoader->PostDigitizer(this) ;
516 if (fLastEvent == -1)
517 fLastEvent = rl->GetNumberOfEvents() - 1 ;
519 fLastEvent = fFirstEvent ; // what is this ??
521 Int_t nEvents = fLastEvent - fFirstEvent + 1;
524 rl->LoadSDigits("EMCAL");
525 for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
527 rl->GetEvent(ievent);
529 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
533 if(strstr(option,"deb"))
535 if(strstr(option,"table")) gObjectTable->Print();
537 //increment the total number of Digits per run
538 fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;
541 emcalLoader->CleanDigitizer() ;
543 if(strstr(option,"tim")){
544 gBenchmark->Stop("EMCALDigitizer");
545 AliInfo(Form("Exec: took %f seconds for Digitizing %f seconds per event",
546 gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nEvents )) ;
550 //____________________________________________________________________________
551 Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks)
553 // Returns the shortest time among all time ticks
555 ticks->Sort() ; //Sort in accordance with times of ticks
557 AliEMCALTick * ctick = (AliEMCALTick *) it.Next() ;
558 Float_t time = ctick->CrossingTime(fTimeThreshold) ;
561 while((t=(AliEMCALTick*) it.Next())){
562 if(t->GetTime() < time) //This tick starts before crossing
567 time = ctick->CrossingTime(fTimeThreshold) ;
572 //____________________________________________________________________________
573 Bool_t AliEMCALDigitizer::Init()
575 // Makes all memory allocations
577 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
579 if ( emcalLoader == 0 ) {
580 Fatal("Init", "Could not obtain the AliEMCALLoader");
585 fLastEvent = fFirstEvent ;
588 fInput = fManager->GetNinputs() ;
592 fInputFileNames = new TString[fInput] ;
593 fEventNames = new TString[fInput] ;
594 fInputFileNames[0] = GetTitle() ;
595 fEventNames[0] = fEventFolderName.Data() ;
597 for (index = 1 ; index < fInput ; index++) {
598 fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0);
599 TString tempo = fManager->GetInputFolderName(index) ;
600 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager
603 //to prevent cleaning of this object while GetEvent is called
604 emcalLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
607 //Calibration instance
608 fCalibData = emcalLoader->CalibData();
612 //____________________________________________________________________________
613 void AliEMCALDigitizer::InitParameters()
615 //parameter initialization for digitizer
616 // Tune parameters - 24-nov-04
618 fMeanPhotonElectron = 3300 ; // electrons per GeV
620 if (fPinNoise == 0. )
621 Warning("InitParameters", "No noise added\n") ;
622 fDigitThreshold = fPinNoise * 3; // 3 * sigma
623 fTimeResolution = 0.3e-9 ; // 300 psc
624 fTimeSignalLength = 1.0e-9 ;
626 fADCchannelEC = 0.00305; // 200./65536 - width of one ADC channel in GeV
627 fADCpedestalEC = 0.009 ; // GeV
628 fNADCEC = (Int_t) TMath::Power(2,16) ; // number of channels in Tower ADC - 65536
630 fTimeThreshold = 0.001*10000000 ; // Means 1 MeV in terms of SDigits amplitude ??
631 // hists. for control; no hists on default
636 //__________________________________________________________________
637 void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
639 // Allows to produce digits by superimposing background and signal event.
640 // It is assumed, that headers file with SIGNAL events is opened in
642 // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed
643 // Thus we avoid writing (changing) huge and expensive
644 // backgound files: all output will be writen into SIGNAL, i.e.
645 // opened in constructor file.
647 // One can open as many files to mix with as one needs.
648 // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
651 if( strcmp(GetName(), "") == 0 )
655 Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
658 // looking for file which contains AliRun
659 if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
660 Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
663 // looking for the file which contains SDigits
664 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
665 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
666 if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
667 fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
668 if ( (gSystem->AccessPathName(fileName)) ) {
669 Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
672 // need to increase the arrays
673 TString tempo = fInputFileNames[fInput-1] ;
674 delete [] fInputFileNames ;
675 fInputFileNames = new TString[fInput+1] ;
676 fInputFileNames[fInput-1] = tempo ;
678 tempo = fEventNames[fInput-1] ;
679 delete [] fEventNames ;
680 fEventNames = new TString[fInput+1] ;
681 fEventNames[fInput-1] = tempo ;
683 fInputFileNames[fInput] = alirunFileName ;
684 fEventNames[fInput] = eventFolderName ;
688 void AliEMCALDigitizer::Print1(Option_t * option)
689 { // 19-nov-04 - just for convinience
694 //__________________________________________________________________
695 void AliEMCALDigitizer::Print(Option_t*)const
697 // Print Digitizer's parameters
698 printf("Print: \n------------------- %s -------------", GetName() ) ;
699 if( strcmp(fEventFolderName.Data(), "") != 0 ){
700 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
704 nStreams = GetNInputStreams() ;
712 for (index = 0 ; index < nStreams ; index++) {
713 TString tempo(fEventNames[index]) ;
715 if ((rl = AliRunLoader::GetRunLoader(tempo)) == 0)
716 rl = AliRunLoader::Open(fInputFileNames[index], tempo) ;
717 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
718 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
719 if ( fEventNames[index] != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
720 fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index] + ".root" ;
721 printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ;
724 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
726 printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
728 printf("\nWith following parameters:\n") ;
730 printf(" Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
731 printf(" Threshold in EMC (fDigitThreshold) = %f\n", fDigitThreshold) ;
732 printf("---------------------------------------------------\n") ;
735 printf("Print: AliEMCALDigitizer not initialized") ;
738 //__________________________________________________________________
739 void AliEMCALDigitizer::PrintDigits(Option_t * option)
741 //utility method for printing digit information
743 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
744 TClonesArray * digits = emcalLoader->Digits() ;
745 TClonesArray * sdigits = emcalLoader->SDigits() ;
747 printf("\n #Digits: %d : sdigits %d ", digits->GetEntriesFast(), sdigits->GetEntriesFast()) ;
748 printf("\n event %d", emcalLoader->GetRunLoader()->GetEventNumber());
750 if(strstr(option,"all")){
752 AliEMCALDigit * digit;
753 printf("\nEMC digits (with primaries):\n") ;
754 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
756 for (index = 0 ; index < digits->GetEntries() ; index++) {
757 digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
758 printf("\n%6d %8d %6.5e %4d %2d : ",
759 digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
761 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
762 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
769 //__________________________________________________________________
770 Float_t AliEMCALDigitizer::TimeOfNoise(void)
772 // Calculates the time signal generated by noise
773 //PH Info("TimeOfNoise", "Change me") ;
774 return gRandom->Rndm() * 1.28E-5;
777 //__________________________________________________________________
778 void AliEMCALDigitizer::Unload()
780 // Unloads the SDigits and Digits
784 for(i = 1 ; i < fInput ; i++){
785 TString tempo(fEventNames[i]) ;
787 if ((rl = AliRunLoader::GetRunLoader(tempo)))
788 rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ;
790 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
791 emcalLoader->UnloadDigits() ;
794 //_________________________________________________________________________________________
795 void AliEMCALDigitizer::WriteDigits()
798 // Makes TreeD in the output file.
799 // Check if branch already exists:
800 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
801 // already existing branches.
802 // else creates branch with Digits, named "EMCAL", title "...",
803 // and branch "AliEMCALDigitizer", with the same title to keep all the parameters
804 // and names of files, from which digits are made.
806 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
808 const TClonesArray * digits = emcalLoader->Digits() ;
809 TTree * treeD = emcalLoader->TreeD();
811 emcalLoader->MakeDigitsContainer();
812 treeD = emcalLoader->TreeD();
815 // -- create Digits branch
816 Int_t bufferSize = 32000 ;
817 TBranch * digitsBranch = 0;
818 if ((digitsBranch = treeD->GetBranch("EMCAL")))
819 digitsBranch->SetAddress(&digits);
821 treeD->Branch("EMCAL","TClonesArray",&digits,bufferSize);
822 //digitsBranch->SetTitle(fEventFolderName);
825 emcalLoader->WriteDigits("OVERWRITE");
826 emcalLoader->WriteDigitizer("OVERWRITE");
832 void AliEMCALDigitizer::Browse(TBrowser* b)
834 if(fHists) b->Add(fHists);
838 TList *AliEMCALDigitizer::BookControlHists(int var)
841 // histograms for monitoring digitizer performance
843 Info("BookControlHists"," started ");
845 const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
847 new TH1F("hDigiN", "#EMCAL digits with fAmp > fDigitThreshold",
848 fNADCEC+1, -0.5, Double_t(fNADCEC));
849 new TH1F("HDigiSumEnergy","Sum.EMCAL energy from digi", 1000, 0.0, 200.);
850 new TH1F("hDigiAmp", "EMCAL digital amplitude", fNADCEC+1, -0.5, Double_t(fNADCEC));
851 new TH1F("hDigiEnergy","EMCAL cell energy", 2000, 0.0, 200.);
852 new TH1F("hDigiAbsId","EMCAL absId cells with fAmp > fDigitThreshold ",
853 geom->GetNCells(), 0.5, Double_t(geom->GetNCells())+0.5);
856 fHists = AliEMCALHistoUtilities::MoveHistsToList("EmcalDigiControlHists", kFALSE);
857 fHists = 0; //huh? JLK 03-Mar-2006
861 void AliEMCALDigitizer::SaveHists(const char* name, Bool_t kSingleKey, const char* opt)
863 AliEMCALHistoUtilities::SaveListOfHists(fHists, name, kSingleKey, opt);