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 from simulated data
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>
67 #include <TObjectTable.h>
71 // --- AliRoot header files ---
74 #include "AliRunDigitizer.h"
75 #include "AliRunLoader.h"
76 #include "AliCDBManager.h"
77 #include "AliCDBEntry.h"
78 #include "AliEMCALDigit.h"
80 #include "AliEMCALLoader.h"
81 #include "AliEMCALDigitizer.h"
82 #include "AliEMCALSDigitizer.h"
83 #include "AliEMCALGeometry.h"
84 #include "AliEMCALTick.h"
86 ClassImp(AliEMCALDigitizer)
89 //____________________________________________________________________________
90 AliEMCALDigitizer::AliEMCALDigitizer()
91 : AliDigitizer("",""),
99 fMeanPhotonElectron(0),
105 fTimeSignalLength(0),
109 fEventFolderName(""),
116 fManager = 0 ; // We work in the standalone mode
119 //____________________________________________________________________________
120 AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName)
121 : AliDigitizer("EMCAL"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName),
122 fDefaultInit(kFALSE),
129 fMeanPhotonElectron(0),
135 fTimeSignalLength(0),
139 fEventFolderName(eventFolderName),
147 fManager = 0 ; // We work in the standalone mode
150 //____________________________________________________________________________
151 AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
152 : AliDigitizer(d.GetName(),d.GetTitle()),
153 fDefaultInit(d.fDefaultInit),
154 fDigitsInRun(d.fDigitsInRun),
157 fInputFileNames(d.fInputFileNames),
158 fEventNames(d.fEventNames),
159 fDigitThreshold(d.fDigitThreshold),
160 fMeanPhotonElectron(d.fMeanPhotonElectron),
161 fPedestal(d.fPedestal),
163 fPinNoise(d.fPinNoise),
164 fTimeResolution(d.fTimeResolution),
165 fTimeThreshold(d.fTimeThreshold),
166 fTimeSignalLength(d.fTimeSignalLength),
167 fADCchannelEC(d.fADCchannelEC),
168 fADCpedestalEC(d.fADCpedestalEC),
170 fEventFolderName(d.fEventFolderName),
171 fFirstEvent(d.fFirstEvent),
172 fLastEvent(d.fLastEvent),
173 fCalibData(d.fCalibData)
178 //____________________________________________________________________________
179 AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd)
180 : AliDigitizer(rd,"EMCAL"+AliConfig::Instance()->GetDigitizerTaskName()),
181 fDefaultInit(kFALSE),
188 fMeanPhotonElectron(0),
194 fTimeSignalLength(0),
203 // ctor Init() is called by RunDigitizer
205 fEventFolderName = fManager->GetInputFolderName(0) ;
206 SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
210 //____________________________________________________________________________
211 AliEMCALDigitizer::~AliEMCALDigitizer()
214 if (AliRunLoader::Instance()) {
215 AliLoader *emcalLoader=0;
216 if ((emcalLoader = AliRunLoader::Instance()->GetDetectorLoader("EMCAL")))
217 emcalLoader->CleanDigitizer();
220 AliDebug(1," no runloader present");
221 delete [] fInputFileNames ;
222 delete [] fEventNames ;
226 //____________________________________________________________________________
227 void AliEMCALDigitizer::Digitize(Int_t event)
230 // Makes the digitization of the collected summable digits
231 // for this it first creates the array of all EMCAL modules
232 // filled with noise and after that adds contributions from
233 // SDigits. This design helps to avoid scanning over the
234 // list of digits to add contribution of any new SDigit.
237 // Note that SDigit energy info is stored as an amplitude, so we
238 // must call the Calibrate() method of the SDigitizer to convert it
239 // back to an energy in GeV before adding it to the Digit
241 static int nEMC=0; //max number of digits possible
243 AliRunLoader *rl = AliRunLoader::Instance();
244 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
245 Int_t readEvent = event ;
246 // fManager is data member from AliDigitizer
248 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ;
249 AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
250 readEvent, GetTitle(), fEventFolderName.Data())) ;
251 rl->GetEvent(readEvent);
253 TClonesArray * digits = emcalLoader->Digits() ;
254 digits->Delete() ; //correct way to clear array when memory is
255 //allocated by objects stored in array
258 AliEMCALGeometry *geom = 0;
259 if (rl->GetAliRun()) {
260 AliEMCAL * emcal = (AliEMCAL*)rl->GetAliRun()->GetDetector("EMCAL");
261 geom = emcal->GetGeometry();
264 AliFatal("Could not get AliRun from runLoader");
266 nEMC = geom->GetNCells();
267 AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s \n", nEMC, geom->GetName()));
271 digits->Expand(nEMC) ;
273 // get first the sdigitizer from the tasks list (must have same name as the digitizer)
274 if ( !emcalLoader->SDigitizer() )
275 emcalLoader->LoadSDigitizer();
276 AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer());
279 Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ;
281 //take all the inputs to add together and load the SDigits
282 TObjArray * sdigArray = new TObjArray(fInput) ;
283 sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
286 for(i = 1 ; i < fInput ; i++){
287 TString tempo(fEventNames[i]) ;
290 AliRunLoader * rl2 = AliRunLoader::GetRunLoader(tempo) ;
293 rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
296 readEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ;
297 Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ;
299 rl2->GetEvent(readEvent);
300 AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
301 sdigArray->AddAt(emcalLoader2->SDigits(), i) ;
304 //Find the first tower with signal
305 Int_t nextSig = nEMC + 1 ;
306 TClonesArray * sdigits ;
307 for(i = 0 ; i < fInput ; i++){
308 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
309 if ( !sdigits->GetEntriesFast() )
311 Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
312 if(curNext < nextSig)
314 AliDebug(1,Form("input %i : #sdigits %i \n",
315 i, sdigits->GetEntriesFast()));
317 AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
319 TArrayI index(fInput) ;
320 index.Reset() ; //Set all indexes to zero
322 AliEMCALDigit * digit ;
323 AliEMCALDigit * curSDigit ;
325 // TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
327 //Put Noise contribution
328 for(absID = 0; absID < nEMC; absID++){ // Nov 30, 2006 by PAI; was from 1 to nEMC
330 // amplitude set to zero, noise will be added later
331 new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0, TimeOfNoise() ); // absID-1->absID
332 //look if we have to add signal?
333 digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
336 //Add SDigits from all inputs
338 //Int_t contrib = 0 ;
340 //Follow PHOS and comment out this timing model til a better one
341 //can be developed - JLK 28-Apr-2008
343 //Float_t a = digit->GetAmp() ;
344 //Float_t b = TMath::Abs( a /fTimeSignalLength) ;
345 //Mark the beginning of the signal
346 //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);
347 //Mark the end of the signal
348 //new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
350 // Calculate time as time of the largest digit
351 Float_t time = digit->GetTime() ;
352 Float_t aTime= digit->GetAmp() ;
355 for(i = 0; i< fInput ; i++){ //loop over (possible) merge sources
356 if(dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
357 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
360 //May be several digits will contribute from the same input
361 while(curSDigit && (curSDigit->GetId() == absID)){
362 //Shift primary to separate primaries belonging different inputs
363 Int_t primaryoffset ;
365 primaryoffset = fManager->GetMask(i) ;
368 curSDigit->ShiftPrimary(primaryoffset) ;
370 //Remove old timing model - JLK 28-April-2008
371 //a = curSDigit->GetAmp() ;
372 //b = a /fTimeSignalLength ;
373 //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime(),0, b);
374 //new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
375 if(curSDigit->GetAmp()>aTime) {
376 aTime = curSDigit->GetAmp();
377 time = curSDigit->GetTime();
380 *digit = *digit + *curSDigit ; //adds amplitudes of each digit
383 if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
384 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
389 //Here we convert the summed amplitude to an energy in GeV
390 energy = sDigitizer->Calibrate(digit->GetAmp()) ; // GeV
391 // add fluctuations for photo-electron creation
392 energy *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
394 //calculate and set time
395 //New timing model needed - JLK 28-April-2008
396 //Float_t time = FrontEdgeTime(ticks) ;
397 digit->SetTime(time) ;
399 //Find next signal module
401 for(i = 0 ; i < fInput ; i++){
402 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
403 Int_t curNext = nextSig ;
404 if(sdigits->GetEntriesFast() > index[i] ){
405 curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]))->GetId() ;
407 if(curNext < nextSig) nextSig = curNext ;
411 energy += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
413 //Now digitize the energy according to the sDigitizer method,
414 //which merely converts the energy to an integer. Later we will
415 //check that the stored value matches our allowed dynamic ranges
416 digit->SetAmp(sDigitizer->Digitize(energy)) ;
417 AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
418 absID, energy, nextSig));
419 } // for(absID = 0; absID < nEMC; absID++)
424 //JLK is it better to call Clear() here?
425 delete sdigArray ; //We should not delete its contents
427 //remove digits below thresholds
428 for(i = 0 ; i < nEMC ; i++){
429 digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
430 Float_t threshold = fDigitThreshold ; //this is in GeV
431 //need to calibrate digit amplitude to energy in GeV for comparison
432 if(sDigitizer->Calibrate( digit->GetAmp() ) < threshold)
433 digits->RemoveAt(i) ;
435 digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
440 Int_t ndigits = digits->GetEntriesFast() ;
443 //After we have done the summing and digitizing to create the
444 //digits, now we want to calibrate the resulting amplitude to match
445 //the dynamic range of our real data.
447 for (i = 0 ; i < ndigits ; i++) {
448 digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
449 digit->SetIndexInList(i) ;
450 energy = sDigitizer->Calibrate(digit->GetAmp()) ;
451 digit->SetAmp(DigitizeEnergy(energy, digit->GetId()) ) ;
456 // //_____________________________________________________________________
457 Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t AbsId)
460 // Returns digitized value of the energy in a cell absId
461 // using the calibration constants stored in the OCDB
462 // or default values if no CalibData object is found.
463 // This effectively converts everything to match the dynamic range
464 // of the real data we will collect
467 const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
470 AliFatal("Did not get geometry from EMCALLoader");
478 Int_t channel = -999;
480 Bool_t bCell = geom->GetCellIndex(AbsId, iSupMod, nModule, nIphi, nIeta) ;
482 Error("DigitizeEnergy","Wrong cell id number : AbsId %i ", AbsId) ;
483 geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
486 fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
487 fADCchannelEC = fCalibData->GetADCchannel(iSupMod,ieta,iphi);
490 channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalEC)/fADCchannelEC )) ;
492 if(channel > fNADCEC )
498 //____________________________________________________________________________
499 void AliEMCALDigitizer::Exec(Option_t *option)
501 // Steering method to process digitization for events
502 // in the range from fFirstEvent to fLastEvent.
503 // This range is optionally set by SetEventRange().
504 // if fLastEvent=-1, then process events until the end.
505 // by default fLastEvent = fFirstEvent (process only one event)
507 if (!fInit) { // to prevent overwrite existing file
508 Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
512 if (strstr(option,"print")) {
518 if(strstr(option,"tim"))
519 gBenchmark->Start("EMCALDigitizer");
521 AliRunLoader *rl = AliRunLoader::Instance();
522 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
524 // Post Digitizer to the white board
525 emcalLoader->PostDigitizer(this) ;
527 if (fLastEvent == -1) {
528 fLastEvent = rl->GetNumberOfEvents() - 1 ;
531 fLastEvent = fFirstEvent ; // what is this ??
533 Int_t nEvents = fLastEvent - fFirstEvent + 1;
536 rl->LoadSDigits("EMCAL");
537 for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
539 rl->GetEvent(ievent);
541 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
545 if(strstr(option,"deb"))
547 if(strstr(option,"table")) gObjectTable->Print();
549 //increment the total number of Digits per run
550 fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;
553 emcalLoader->CleanDigitizer() ;
555 if(strstr(option,"tim")){
556 gBenchmark->Stop("EMCALDigitizer");
557 AliInfo(Form("Exec: took %f seconds for Digitizing %f seconds per event",
558 gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nEvents )) ;
562 //____________________________________________________________________________
563 Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks)
565 // Returns the shortest time among all time ticks
567 ticks->Sort() ; //Sort in accordance with times of ticks
569 AliEMCALTick * ctick = (AliEMCALTick *) it.Next() ;
570 Float_t time = ctick->CrossingTime(fTimeThreshold) ;
573 while((t=(AliEMCALTick*) it.Next())){
574 if(t->GetTime() < time) //This tick starts before crossing
579 time = ctick->CrossingTime(fTimeThreshold) ;
584 //____________________________________________________________________________
585 Bool_t AliEMCALDigitizer::Init()
587 // Makes all memory allocations
589 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
591 if ( emcalLoader == 0 ) {
592 Fatal("Init", "Could not obtain the AliEMCALLoader");
597 fLastEvent = fFirstEvent ;
600 fInput = fManager->GetNinputs() ;
604 fInputFileNames = new TString[fInput] ;
605 fEventNames = new TString[fInput] ;
606 fInputFileNames[0] = GetTitle() ;
607 fEventNames[0] = fEventFolderName.Data() ;
609 for (index = 1 ; index < fInput ; index++) {
610 fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0);
611 TString tempo = fManager->GetInputFolderName(index) ;
612 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager
615 //to prevent cleaning of this object while GetEvent is called
616 emcalLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
618 //Calibration instance
619 fCalibData = emcalLoader->CalibData();
623 //____________________________________________________________________________
624 void AliEMCALDigitizer::InitParameters()
626 // Parameter initialization for digitizer
627 // Tune parameters - 24-nov-04; Apr 29, 2007
628 // New parameters JLK 14-Apr-2008
630 fMeanPhotonElectron = 4400; // electrons per GeV
631 fPinNoise = 0.037; // pin noise in GEV from analysis test beam data
632 if (fPinNoise == 0. )
633 Warning("InitParameters", "No noise added\n") ;
634 fDigitThreshold = fPinNoise * 3; // 3 * sigma
635 fTimeResolution = 0.3e-9 ; // 300 psc
636 fTimeSignalLength = 1.0e-9 ;
638 // These defaults are normally not used.
639 // Values are read from calibration database instead
640 fADCchannelEC = 0.0153; // Update 24 Apr 2007: 250./16/1024 - width of one ADC channel in GeV
641 fADCpedestalEC = 0.0 ; // GeV
642 fNADCEC = (Int_t) TMath::Power(2,16) ; // number of channels in Tower ADC - 65536
644 fTimeThreshold = 0.001*10000000 ; // Means 1 MeV in terms of SDigits amplitude ??
648 //__________________________________________________________________
649 void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
651 // Allows to produce digits by superimposing background and signal event.
652 // It is assumed, that headers file with SIGNAL events is opened in
654 // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed
655 // Thus we avoid writing (changing) huge and expensive
656 // backgound files: all output will be writen into SIGNAL, i.e.
657 // opened in constructor file.
659 // One can open as many files to mix with as one needs.
660 // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
663 if( strcmp(GetName(), "") == 0 )
667 Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
670 // looking for file which contains AliRun
671 if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
672 Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
675 // looking for the file which contains SDigits
676 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
677 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
678 if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
679 fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
680 if ( (gSystem->AccessPathName(fileName)) ) {
681 Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
684 // need to increase the arrays
685 // MvL: This code only works when fInput == 1, I think.
686 TString tempo = fInputFileNames[fInput-1] ;
687 delete [] fInputFileNames ;
688 fInputFileNames = new TString[fInput+1] ;
689 fInputFileNames[fInput-1] = tempo ;
691 tempo = fEventNames[fInput-1] ;
692 delete [] fEventNames ;
693 fEventNames = new TString[fInput+1] ;
694 fEventNames[fInput-1] = tempo ;
696 fInputFileNames[fInput] = alirunFileName ;
697 fEventNames[fInput] = eventFolderName ;
701 //__________________________________________________________________
702 void AliEMCALDigitizer::Print1(Option_t * option)
703 { // 19-nov-04 - just for convinience
708 //__________________________________________________________________
709 void AliEMCALDigitizer::Print(Option_t*)const
711 // Print Digitizer's parameters
712 printf("Print: \n------------------- %s -------------", GetName() ) ;
713 if( strcmp(fEventFolderName.Data(), "") != 0 ){
714 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
718 nStreams = GetNInputStreams() ;
726 for (index = 0 ; index < nStreams ; index++) {
727 TString tempo(fEventNames[index]) ;
729 if ((rl = AliRunLoader::GetRunLoader(tempo)) == 0)
730 rl = AliRunLoader::Open(fInputFileNames[index], tempo) ;
731 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
732 TString fileName( emcalLoader->GetSDigitsFileName() ) ;
733 if ( fEventNames[index] != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name
734 fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index] + ".root" ;
735 printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ;
738 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
740 printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
742 printf("\nWith following parameters:\n") ;
744 printf(" Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
745 printf(" Threshold in EMC (fDigitThreshold) = %f\n", fDigitThreshold) ;
746 printf("---------------------------------------------------\n") ;
749 printf("Print: AliEMCALDigitizer not initialized") ;
752 //__________________________________________________________________
753 void AliEMCALDigitizer::PrintDigits(Option_t * option)
755 //utility method for printing digit information
757 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
758 TClonesArray * digits = emcalLoader->Digits() ;
759 TClonesArray * sdigits = emcalLoader->SDigits() ;
761 printf("\n #Digits: %d : sdigits %d ", digits->GetEntriesFast(), sdigits->GetEntriesFast()) ;
762 printf("\n event %d", emcalLoader->GetRunLoader()->GetEventNumber());
764 if(strstr(option,"all")){
766 AliEMCALDigit * digit;
767 printf("\nEMC digits (with primaries):\n") ;
768 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
770 for (index = 0 ; index < digits->GetEntries() ; index++) {
771 digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
772 printf("\n%6d %8d %6.5e %4d %2d : ",
773 digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
775 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
776 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
783 //__________________________________________________________________
784 Float_t AliEMCALDigitizer::TimeOfNoise(void)
786 // Calculates the time signal generated by noise
787 //PH Info("TimeOfNoise", "Change me") ;
788 return gRandom->Rndm() * 1.28E-5;
791 //__________________________________________________________________
792 void AliEMCALDigitizer::Unload()
794 // Unloads the SDigits and Digits
798 for(i = 1 ; i < fInput ; i++){
799 TString tempo(fEventNames[i]) ;
801 if ((rl = AliRunLoader::GetRunLoader(tempo)))
802 rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ;
804 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
805 emcalLoader->UnloadDigits() ;
808 //_________________________________________________________________________________________
809 void AliEMCALDigitizer::WriteDigits()
812 // Makes TreeD in the output file.
813 // Check if branch already exists:
814 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
815 // already existing branches.
816 // else creates branch with Digits, named "EMCAL", title "...",
817 // and branch "AliEMCALDigitizer", with the same title to keep all the parameters
818 // and names of files, from which digits are made.
820 AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
822 const TClonesArray * digits = emcalLoader->Digits() ;
823 TTree * treeD = emcalLoader->TreeD();
825 emcalLoader->MakeDigitsContainer();
826 treeD = emcalLoader->TreeD();
829 // -- create Digits branch
830 Int_t bufferSize = 32000 ;
831 TBranch * digitsBranch = 0;
832 if ((digitsBranch = treeD->GetBranch("EMCAL"))) {
833 digitsBranch->SetAddress(&digits);
834 AliWarning("Digits Branch already exists. Not all digits will be visible");
837 treeD->Branch("EMCAL","TClonesArray",&digits,bufferSize);
838 //digitsBranch->SetTitle(fEventFolderName);
841 emcalLoader->WriteDigits("OVERWRITE");
842 emcalLoader->WriteDigitizer("OVERWRITE");
848 //__________________________________________________________________
849 void AliEMCALDigitizer::Browse(TBrowser* b)