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 ///_________________________________________________________________________________
60 // --- ROOT system ---
66 #include "TObjString.h"
67 #include "TGeometry.h"
68 #include "TBenchmark.h"
70 // --- Standard library ---
72 // --- AliRoot header files ---
74 #include "AliHeader.h"
75 #include "AliStream.h"
76 #include "AliRunDigitizer.h"
77 #include "AliEMCALDigit.h"
79 #include "AliEMCALGetter.h"
80 #include "AliEMCALDigitizer.h"
81 #include "AliEMCALSDigitizer.h"
82 #include "AliEMCALGeometry.h"
83 #include "AliEMCALTick.h"
85 ClassImp(AliEMCALDigitizer)
88 //____________________________________________________________________________
89 AliEMCALDigitizer::AliEMCALDigitizer():AliDigitizer("",""),
96 fDefaultInit = kTRUE ;
97 fManager = 0 ; // We work in the standalong mode
98 fEventFolderName = "" ;
101 //____________________________________________________________________________
102 AliEMCALDigitizer::AliEMCALDigitizer(const TString alirunFileName, const TString eventFolderName):
103 AliDigitizer("EMCAL"+AliConfig::fgkDigitizerTaskName, alirunFileName),
104 fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
110 fDefaultInit = kFALSE ;
111 fManager = 0 ; // We work in the standalong mode
114 //____________________________________________________________________________
115 AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d) : AliDigitizer(d)
119 SetName(d.GetName()) ;
120 SetTitle(d.GetTitle()) ;
121 fDigitThreshold = d.fDigitThreshold ;
122 fMeanPhotonElectron = d.fMeanPhotonElectron ;
123 fPedestal = d.fPedestal ;
125 fPinNoise = d.fPinNoise ;
126 fTimeResolution = d.fTimeResolution ;
127 fTimeThreshold = d.fTimeThreshold ;
128 fTimeSignalLength = d.fTimeSignalLength ;
129 fADCchannelEC = d.fADCchannelEC ;
130 fADCpedestalEC = d.fADCpedestalEC ;
131 fNADCEC = d.fNADCEC ;
132 fADCchannelHC = d.fADCchannelHC ;
133 fADCpedestalHC = d.fADCpedestalHC ;
134 fNADCHC = d.fNADCHC ;
135 fADCchannelPRE = d.fADCchannelPRE ;
136 fADCpedestalPRE = d.fADCpedestalPRE ;
137 fNADCPRE = d.fNADCPRE ;
138 fEventFolderName = d.fEventFolderName;
141 //____________________________________________________________________________
142 AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd):
143 AliDigitizer(rd,"EMCAL"+AliConfig::fgkDigitizerTaskName),
148 SetName(fManager->GetInputFolderName(0)) ;
149 // take title as name of stream 0
150 SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
153 fDefaultInit = kFALSE ;
156 //____________________________________________________________________________
157 AliEMCALDigitizer::~AliEMCALDigitizer()
160 delete [] fInputFileNames ;
161 delete [] fEventNames ;
165 //____________________________________________________________________________
166 void AliEMCALDigitizer::Digitize(const Int_t event)
169 // Makes the digitization of the collected summable digits
170 // for this it first creates the array of all EMCAL modules
171 // filled with noise (different for EMC, CPV and PPSD) and
172 // after that adds contributions from SDigits. This design
173 // helps to avoid scanning over the list of digits to add
174 // contribution of any new SDigit.
176 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
177 TClonesArray * digits = gime->Digits() ;
180 const AliEMCALGeometry *geom = gime->EMCALGeometry() ;
181 //Making digits with noise, first EMC
183 if (geom->GetNHCLayers() > 0 )
184 nEMC = 3*geom->GetNPhi()*geom->GetNZ(); //max number of digits possible (Preshower, ECAL, HCAL)
186 nEMC = 2*geom->GetNPhi()*geom->GetNZ(); //max number of digits possible (Preshower, ECAL)
190 digits->Expand(nEMC) ;
192 // get first the sdigitizer from the tasks list (must have same name as the digitizer)
193 if ( !gime->SDigitizer() )
194 gime->LoadSDigitizer();
195 AliEMCALSDigitizer * sDigitizer = gime->SDigitizer();
198 Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ;
200 //take all the inputs to add together and load the SDigits
201 TObjArray * sdigArray = new TObjArray(fInput) ;
202 sdigArray->AddAt(gime->SDigits(), 0) ;
204 for(i = 1 ; i < fInput ; i++){
205 TString tempo(fEventNames[i]) ;
207 AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ;
208 gime->Event(event,"S");
209 sdigArray->AddAt(gime->SDigits(), i) ;
212 //Find the first tower with signal
213 Int_t nextSig = nEMC + 1 ;
214 TClonesArray * sdigits ;
215 for(i = 0 ; i < fInput ; i++){
216 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
217 if ( !sdigits->GetEntriesFast() )
219 Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
220 if(curNext < nextSig)
224 TArrayI index(fInput) ;
225 index.Reset() ; //Set all indexes to zero
227 AliEMCALDigit * digit ;
228 AliEMCALDigit * curSDigit ;
230 TClonesArray * ticks = new TClonesArray("AliEMCALTick",1000) ;
232 //Put Noise contribution
233 for(absID = 1; absID <= nEMC; absID++){
235 // amplitude set to zero, noise will be added later
236 new((*digits)[absID-1]) AliEMCALDigit( -1, -1, absID, 0, TimeOfNoise() ) ;
237 //look if we have to add signal?
238 digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID-1)) ;
241 //Add SDigits from all inputs
244 Float_t a = digit->GetAmp() ;
245 Float_t b = TMath::Abs( a /fTimeSignalLength) ;
246 //Mark the beginning of the signal
247 new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);
248 //Mark the end of the ignal
249 new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
252 for(i = 0; i< fInput ; i++){ //loop over (possible) merge sources
253 if(dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
254 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
257 //May be several digits will contribute from the same input
258 while(curSDigit && curSDigit->GetId() == absID){
259 //Shift primary to separate primaries belonging different inputs
260 Int_t primaryoffset ;
262 primaryoffset = fManager->GetMask(i) ;
265 curSDigit->ShiftPrimary(primaryoffset) ;
267 a = curSDigit->GetAmp() ;
268 b = a /fTimeSignalLength ;
269 new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime(),0, b);
270 new((*ticks)[contrib++]) AliEMCALTick(curSDigit->GetTime()+fTimeSignalLength, -a, -b);
272 *digit = *digit + *curSDigit ; //add energies
275 if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
276 curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
281 // add fluctuations for photo-electron creation
282 amp = sDigitizer->Calibrate(digit->GetAmp()) ; // GeV
283 amp *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
285 //calculate and set time
286 Float_t time = FrontEdgeTime(ticks) ;
287 digit->SetTime(time) ;
289 //Find next signal module
291 for(i = 0 ; i < fInput ; i++){
292 sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
293 Int_t curNext = nextSig ;
294 if(sdigits->GetEntriesFast() > index[i] ){
295 curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]))->GetId() ;
297 if(curNext < nextSig) nextSig = curNext ;
302 if (geom->IsInECA(digit->GetId()))
303 amp += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
304 else if (geom->IsInPRE(digit->GetId()))
305 amp += TMath::Abs(gRandom->Gaus(0., fPinNoise/100.)) ; // arbitrarely divide by 100, assuming that the gain of APD will be higher
306 else if (geom->IsInHCA(digit->GetId()))
307 amp += TMath::Abs(gRandom->Gaus(0., fPinNoise/10.)) ; // arbitrarely divide by 10, assuming that the gain of APD will be higher
308 digit->SetAmp(sDigitizer->Digitize(amp)) ;
314 delete sdigArray ; //We should not delete its contents
316 //remove digits below thresholds
317 for(i = 0 ; i < nEMC ; i++){
318 digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
319 Float_t threshold = 0 ;
321 if (geom->IsInECA(digit->GetId()))
322 threshold = fDigitThreshold ;
323 else if (geom->IsInPRE(digit->GetId()))
324 threshold = fDigitThreshold / 100. ; // arbitrary see before when noise is added
325 else if (geom->IsInHCA(digit->GetId()))
326 threshold = fDigitThreshold / 10. ; // arbitrary see before when noise is added
328 if(sDigitizer->Calibrate( digit->GetAmp() ) < threshold)
329 digits->RemoveAt(i) ;
331 digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
336 Int_t ndigits = digits->GetEntriesFast() ;
337 digits->Expand(ndigits) ;
339 //Set indexes in list of digits
340 for (i = 0 ; i < ndigits ; i++) {
341 digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
342 digit->SetIndexInList(i) ;
343 Float_t energy = sDigitizer->Calibrate(digit->GetAmp()) ;
344 digit->SetAmp(DigitizeEnergy(energy,digit->GetId()) ) ;
348 //____________________________________________________________________________
350 Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
352 Int_t channel = -999;
353 AliEMCALGeometry * geom = AliEMCALGetter::Instance()->EMCALGeometry() ;
355 if(geom->IsInPRE(absId)){ //digitize as PRE section
356 channel = static_cast<Int_t>(TMath::Ceil( (energy + fADCpedestalPRE)/fADCchannelPRE )) ;
357 if(channel > fNADCPRE )
360 else if(geom->IsInECA(absId)){ //digitize as ECAL section
361 channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalEC)/fADCchannelEC )) ;
362 if(channel > fNADCEC )
365 else if(geom->IsInHCA(absId)){ //digitize as HCAL section
366 channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalHC)/fADCchannelHC )) ;
367 if(channel > fNADCHC )
374 //____________________________________________________________________________
375 void AliEMCALDigitizer::Exec(Option_t *option)
379 if (!fInit) { // to prevent overwrite existing file
380 Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
384 if (strstr(option,"print")) {
389 if(strstr(option,"tim"))
390 gBenchmark->Start("EMCALDigitizer");
393 fInput = fManager->GetNinputs() ;
395 AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
397 Int_t nevents = gime->MaxEvent() ;;
401 for(ievent = 0; ievent < nevents; ievent++){
403 gime->Event(ievent,"S") ;
405 Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
409 if(strstr(option,"deb"))
412 //increment the total number of Digits per run
413 fDigitsInRun += gime->Digits()->GetEntriesFast() ;
416 if(strstr(option,"tim")){
417 gBenchmark->Stop("EMCALDigitizer");
418 Info("Exec", "took %f seconds for Digitizing %f seconds per event",
419 gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nevents ) ;
423 //____________________________________________________________________________
424 Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks)
426 // Returns the shortest time among all time ticks
428 ticks->Sort() ; //Sort in accordance with times of ticks
430 AliEMCALTick * ctick = (AliEMCALTick *) it.Next() ;
431 Float_t time = ctick->CrossingTime(fTimeThreshold) ;
434 while((t=(AliEMCALTick*) it.Next())){
435 if(t->GetTime() < time) //This tick starts before crossing
440 time = ctick->CrossingTime(fTimeThreshold) ;
445 //____________________________________________________________________________
446 Bool_t AliEMCALDigitizer::Init()
448 // Makes all memory allocations
450 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
452 Error("Init", "Could not obtain the Getter object for file %s and event %s !", GetTitle(), fEventFolderName.Data()) ;
456 TString opt("Digits") ;
457 if(gime->VersionExists(opt) ) {
458 Error( "Init", "Give a version name different from %s", fEventFolderName.Data() ) ;
462 // Post Digitizer to the white board
463 gime->PostDigitizer(this) ;
466 fInput = fManager->GetNinputs() ;
470 fInputFileNames = new TString[fInput] ;
471 fEventNames = new TString[fInput] ;
472 fInputFileNames[0] = GetTitle() ;
473 fEventNames[0] = fEventFolderName.Data() ;
475 for (index = 1 ; index < fInput ; index++) {
476 fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0);
477 TString tempo = fManager->GetInputFolderName(index) ;
478 fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager
481 //to prevent cleaning of this object while GetEvent is called
482 gime->EmcalLoader()->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
487 //____________________________________________________________________________
488 void AliEMCALDigitizer::InitParameters()
490 fMeanPhotonElectron = 1250 ; // electrons per GeV
491 fPinNoise = 0.001 ; // noise equivalent GeV (random choice)
492 if (fPinNoise == 0. )
493 Warning("InitParameters", "No noise added\n") ;
494 fDigitThreshold = fPinNoise * 3; //2 sigma
495 fTimeResolution = 0.5e-9 ;
496 fTimeSignalLength = 1.0e-9 ;
498 fADCchannelEC = 0.000220; // width of one ADC channel in GeV
499 fADCpedestalEC = 0.005 ; // GeV
500 fNADCEC = (Int_t) TMath::Power(2,16) ; // number of channels in Tower ADC
502 fADCchannelHC = 0.000220; // width of one ADC channel in GeV
503 fADCpedestalHC = 0.005 ; // GeV
504 fNADCHC = (Int_t) TMath::Power(2,16) ; // number of channels in Tower ADC
506 fADCchannelPRE = 0.0000300; // width of one ADC channel in Pre Shower
507 fADCpedestalPRE = 0.005 ; // GeV
508 fNADCPRE = (Int_t) TMath::Power(2,12); // number of channels in Pre ShowerADC
510 fTimeThreshold = 0.001*10000000 ; //Means 1 MeV in terms of SDigits amplitude
514 //__________________________________________________________________
515 void AliEMCALDigitizer::MixWith(const TString alirunFileName, const TString eventFolderName)
517 // Allows to produce digits by superimposing background and signal event.
518 // It is assumed, that headers file with SIGNAL events is opened in
520 // Sets the BACKGROUND event, with which the SIGNAL event is to be mixed
521 // Thus we avoid writing (changing) huge and expensive
522 // backgound files: all output will be writen into SIGNAL, i.e.
523 // opened in constructor file.
525 // One can open as many files to mix with as one needs.
526 // However only Sdigits with the same name (i.e. constructed with the same SDigitizer)
529 if( strcmp(GetName(), "") == 0 )
533 Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
536 // looking for file which contains AliRun
537 if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
538 Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
541 // looking for the file which contains SDigits
542 AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
543 TString fileName( gime->GetSDigitsFileName() ) ;
544 if ( eventFolderName != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
545 fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
546 if ( (gSystem->AccessPathName(fileName)) ) {
547 Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
550 // need to increase the arrays
551 TString tempo = fInputFileNames[fInput-1] ;
552 delete [] fInputFileNames ;
553 fInputFileNames = new TString[fInput+1] ;
554 fInputFileNames[fInput-1] = tempo ;
556 tempo = fEventNames[fInput-1] ;
557 delete [] fEventNames ;
558 fEventNames = new TString[fInput+1] ;
559 fEventNames[fInput-1] = tempo ;
561 fInputFileNames[fInput] = alirunFileName ;
562 fEventNames[fInput] = eventFolderName ;
566 //__________________________________________________________________
567 void AliEMCALDigitizer::Print()const
569 // Print Digitizer's parameters
570 Info("Print", "\n------------------- %s -------------", GetName() ) ;
571 if( strcmp(fEventFolderName.Data(), "") != 0 ){
572 printf(" Writing Digits to branch with title %s\n", fEventFolderName.Data()) ;
576 nStreams = GetNInputStreams() ;
581 for (index = 0 ; index < nStreams ; index++) {
582 TString tempo(fEventNames[index]) ;
584 AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[index], tempo) ;
585 TString fileName( gime->GetSDigitsFileName() ) ;
586 if ( fEventNames[index] != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name
587 fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index] + ".root" ;
588 printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ;
590 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
591 printf("\nWriting digits to %s", gime->GetDigitsFileName().Data()) ;
593 printf("\nWith following parameters:\n") ;
595 printf(" Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
596 printf(" Threshold in EMC (fDigitThreshold) = %f\n", fDigitThreshold) ;
597 printf("---------------------------------------------------\n") ;
600 Info("Print", "AliEMCALDigitizer not initialized") ;
603 //__________________________________________________________________
604 void AliEMCALDigitizer::PrintDigits(Option_t * option){
606 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
607 TClonesArray * digits = gime->Digits() ;
609 Info("PrintDigits", "%d", digits->GetEntriesFast()) ;
610 printf("\nevent %d", gAlice->GetEvNumber()) ;
611 printf("\n Number of entries in Digits list %d", digits->GetEntriesFast() ) ;
613 if(strstr(option,"all")){
615 AliEMCALDigit * digit;
616 printf("\nEMC digits (with primaries):\n") ;
617 printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
619 for (index = 0 ; index < digits->GetEntries() ; index++) {
620 digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
621 printf("\n%6d %8d %6.5e %4d %2d : ",
622 digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
624 for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
625 printf("%d ",digit->GetPrimary(iprimary+1) ) ;
631 //__________________________________________________________________
632 Float_t AliEMCALDigitizer::TimeOfNoise(void)
633 { // Calculates the time signal generated by noise
634 //to be rewritten, now returns just big number
639 //__________________________________________________________________
640 void AliEMCALDigitizer::Unload()
644 for(i = 1 ; i < fInput ; i++){
645 TString tempo(fEventNames[i]) ;
647 AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ;
648 gime->EmcalLoader()->UnloadSDigits() ;
651 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
652 gime->EmcalLoader()->UnloadDigits() ;
655 //_________________________________________________________________________________________
656 void AliEMCALDigitizer::WriteDigits()
659 // Makes TreeD in the output file.
660 // Check if branch already exists:
661 // if yes, exit without writing: ROOT TTree does not support overwriting/updating of
662 // already existing branches.
663 // else creates branch with Digits, named "EMCAL", title "...",
664 // and branch "AliEMCALDigitizer", with the same title to keep all the parameters
665 // and names of files, from which digits are made.
667 AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;
668 const TClonesArray * digits = gime->Digits() ;
669 TTree * treeD = gime->TreeD();
671 // -- create Digits branch
672 Int_t bufferSize = 32000 ;
673 TBranch * digitsBranch = treeD->Branch("EMCAL",&digits,bufferSize);
674 digitsBranch->SetTitle(fEventFolderName);
675 digitsBranch->Fill() ;
677 gime->WriteDigits("OVERWRITE");
678 gime->WriteDigitizer("OVERWRITE");