update of Jenn and Marco
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALDigitizer.cxx
index 090c9e1..7bfc71b 100644 (file)
 // Modif: 
 //  August 2002 Yves Schutz: clone PHOS as closely as possible and intoduction
 //                           of new  IO (à la PHOS)
-///_________________________________________________________________________________
+//  November 2003 Aleksei Pavlinov : adopted for Shish-Kebab geometry 
+//_________________________________________________________________________________
 
 // --- ROOT system ---
+#include "TROOT.h"
 #include "TTree.h"
 #include "TSystem.h"
 #include "TBenchmark.h"
-
-// --- Standard library ---
+#include "TList.h"
+#include "TH1.h"
+#include "TBrowser.h"
+#include "TObjectTable.h"
 
 // --- AliRoot header files ---
 #include "AliRunDigitizer.h"
+#include "AliRunLoader.h"
 #include "AliEMCALDigit.h"
 #include "AliEMCAL.h"
-#include "AliEMCALGetter.h"
+#include "AliEMCALLoader.h"
 #include "AliEMCALDigitizer.h"
 #include "AliEMCALSDigitizer.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALTick.h"
+#include "AliEMCALJetMicroDst.h"
 
 ClassImp(AliEMCALDigitizer)
 
@@ -92,7 +98,7 @@ ClassImp(AliEMCALDigitizer)
 
 //____________________________________________________________________________ 
 AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName):
-  AliDigitizer("EMCAL"+AliConfig::fgkDigitizerTaskName, alirunFileName),
+  AliDigitizer("EMCAL"+AliConfig::Instance()->GetDigitizerTaskName(), alirunFileName),
   fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
 {
   // ctor
@@ -126,7 +132,7 @@ AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d) : AliDigitizer
 
 //____________________________________________________________________________ 
 AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd):
- AliDigitizer(rd,"EMCAL"+AliConfig::fgkDigitizerTaskName),
+ AliDigitizer(rd,"EMCAL"+AliConfig::Instance()->GetDigitizerTaskName()),
  fEventFolderName(0)
 {
   // ctor Init() is called by RunDigitizer
@@ -140,12 +146,15 @@ AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd):
 //____________________________________________________________________________ 
   AliEMCALDigitizer::~AliEMCALDigitizer()
 {
-  // dtor
-  AliEMCALGetter * gime =AliEMCALGetter::Instance(GetTitle(),fEventFolderName);
-  gime->EmcalLoader()->CleanDigitizer();
+  if (AliRunLoader::GetRunLoader()) {
+    AliLoader *emcalLoader=0;
+    if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
+      emcalLoader->CleanDigitizer();
+  }
+  else
+    AliDebug(1," no runloader present");
   delete [] fInputFileNames ; 
   delete [] fEventNames ; 
-
 }
 
 //____________________________________________________________________________
@@ -158,45 +167,59 @@ void AliEMCALDigitizer::Digitize(Int_t event)
   // after that adds contributions from SDigits. This design 
   // helps to avoid scanning over the list of digits to add 
   // contribution of any new SDigit.
+  static int isTrd1Geom = -1; // -1 - mean undefined 
+  static int nEMC=0; //max number of digits possible
 
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+  AliRunLoader *rl = AliRunLoader::GetRunLoader();
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
   Int_t ReadEvent = event ; 
+  // fManager is data member from AliDigitizer
   if (fManager) 
     ReadEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetCurrentEventNumber() ; 
-  Info("Digitize", "Adding event %d from input stream 0", ReadEvent) ; 
-  gime->Event(ReadEvent, "S") ;
-  TClonesArray * digits = gime->Digits() ; 
+  AliDebug(1,Form("Adding event %d from input stream 0 %s %s", 
+                 ReadEvent, GetTitle(), fEventFolderName.Data())) ; 
+  rl->GetEvent(ReadEvent);
+
+  TClonesArray * digits = emcalLoader->Digits() ; 
   digits->Clear() ;
 
-  const AliEMCALGeometry *geom = gime->EMCALGeometry() ; 
+  const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
+  if(isTrd1Geom < 0) { 
+    TString ng(geom->GetName());
+    isTrd1Geom = 0;
+    if(ng.Contains("SHISH") &&  ng.Contains("TRD1")) isTrd1Geom = 1;
 
-  Int_t nEMC = geom->GetNPhi()*geom->GetNZ(); //max number of digits possible
-  
+    if(isTrd1Geom == 0) nEMC = geom->GetNPhi()*geom->GetNZ();
+    else                nEMC = geom->GetNCells();
+    AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s | isTrd1Geom %i\n", nEMC, geom->GetName(), isTrd1Geom));
+  }
   Int_t absID ;
 
   digits->Expand(nEMC) ;
 
   // get first the sdigitizer from the tasks list (must have same name as the digitizer)
-  if ( !gime->SDigitizer() ) 
-    gime->LoadSDigitizer();
-  AliEMCALSDigitizer * sDigitizer = gime->SDigitizer(); 
+  if ( !emcalLoader->SDigitizer() ) 
+    emcalLoader->LoadSDigitizer();
+  AliEMCALSDigitizer * sDigitizer = dynamic_cast<AliEMCALSDigitizer*>(emcalLoader->SDigitizer()); 
   
   if ( !sDigitizer )
     Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
 
   //take all the inputs to add together and load the SDigits
   TObjArray * sdigArray = new TObjArray(fInput) ;
-  sdigArray->AddAt(gime->SDigits(), 0) ;
+  sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
   Int_t i ;
+
   for(i = 1 ; i < fInput ; i++){
     TString tempo(fEventNames[i]) ; 
     tempo += i ;
-    AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ; 
+    rl = AliRunLoader::Open(fInputFileNames[i], tempo) ; 
     if (fManager) 
       ReadEvent = dynamic_cast<AliStream*>(fManager->GetInputStream(i))->GetCurrentEventNumber() ; 
-    Info("Digitize", "Adding event %d from input stream %d", ReadEvent, i) ; 
-    gime->Event(ReadEvent,"S");
-    sdigArray->AddAt(gime->SDigits(), i) ;
+    Info("Digitize", "Adding event %d from input stream %d %s %s", ReadEvent, i, fInputFileNames[i].Data(), tempo.Data()) ; 
+    rl->LoadSDigits();
+    rl->GetEvent(ReadEvent);
+    sdigArray->AddAt(emcalLoader->SDigits(), i) ;
   }
   
   //Find the first tower with signal
@@ -209,7 +232,10 @@ void AliEMCALDigitizer::Digitize(Int_t event)
     Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
      if(curNext < nextSig) 
        nextSig = curNext ;
+     AliDebug(1,Form("input %i : #sdigits %i \n",
+                    i, sdigits->GetEntriesFast()));
   }
+  AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
 
   TArrayI index(fInput) ;
   index.Reset() ;  //Set all indexes to zero
@@ -263,7 +289,7 @@ void AliEMCALDigitizer::Digitize(Int_t event)
 
          index[i]++ ;
          if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
-           curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;            
+           curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;
          else
            curSDigit = 0 ;
        }
@@ -290,7 +316,9 @@ void AliEMCALDigitizer::Digitize(Int_t event)
     // add the noise now
     amp += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
     digit->SetAmp(sDigitizer->Digitize(amp)) ;  
-  }
+    AliDebug(10,Form(" absID %5i amp %f nextSig %5i\n",
+                    absID, amp, nextSig));
+  } // for(absID = 1; absID <= nEMC; absID++)
   
   ticks->Delete() ;
   delete ticks ;
@@ -312,13 +340,20 @@ void AliEMCALDigitizer::Digitize(Int_t event)
   Int_t ndigits = digits->GetEntriesFast() ; 
   digits->Expand(ndigits) ;
   
-  //Set indexes in list of digits
+  //Set indexes in list of digits and fill hists.
+  sv::FillH1(fHists, 0, Double_t(ndigits));
+  Float_t energy=0., esum=0.;
   for (i = 0 ; i < ndigits ; i++) { 
     digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ; 
     digit->SetIndexInList(i) ; 
-    Float_t energy = sDigitizer->Calibrate(digit->GetAmp()) ;
-    digit->SetAmp(DigitizeEnergy(energy) ) ;
+    energy = sDigitizer->Calibrate(digit->GetAmp()) ;
+    esum += energy;
+    digit->SetAmp(DigitizeEnergy(energy) ) ; // for what ??
+    sv::FillH1(fHists, 2, double(digit->GetAmp()));
+    sv::FillH1(fHists, 3, double(energy));
+    sv::FillH1(fHists, 4, double(digit->GetId()));
   }
+  sv::FillH1(fHists, 1, esum);
 }
 
 //____________________________________________________________________________
@@ -353,21 +388,25 @@ void AliEMCALDigitizer::Exec(Option_t *option)
   
   if(strstr(option,"tim"))
     gBenchmark->Start("EMCALDigitizer");
+
+  AliRunLoader *rl = AliRunLoader::GetRunLoader();
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
+
+  // Post Digitizer to the white board
+  emcalLoader->PostDigitizer(this) ;
   
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle()) ;
-   
   if (fLastEvent == -1) 
-    fLastEvent = gime->MaxEvent() - 1 ;
+    fLastEvent = rl->GetNumberOfEvents() - 1 ;
   else if (fManager) 
-    fLastEvent = fFirstEvent ; 
+    fLastEvent = fFirstEvent ; // what is this ??
 
   Int_t nEvents   = fLastEvent - fFirstEvent + 1;
-  
-  Int_t ievent ;
+  Int_t ievent;
 
+  rl->LoadSDigits("EMCAL");
   for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
-  
-    gime->Event(ievent,"S") ; 
+    //gime->Event(ievent,"S") ; 
+    rl->GetEvent(ievent);
 
     Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
 
@@ -375,11 +414,15 @@ void AliEMCALDigitizer::Exec(Option_t *option)
 
     if(strstr(option,"deb"))
       PrintDigits(option);
+    if(strstr(option,"table")) gObjectTable->Print();
 
     //increment the total number of Digits per run 
-    fDigitsInRun += gime->Digits()->GetEntriesFast() ;  
+    fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;  
   }
-  
+  //  gime->WriteDigitizer("OVERWRITE");
+
+  emcalLoader->CleanDigitizer() ;
+
   if(strstr(option,"tim")){
     gBenchmark->Stop("EMCALDigitizer");
     printf("Exec: took %f seconds for Digitizing %f seconds per event", 
@@ -414,21 +457,13 @@ Bool_t AliEMCALDigitizer::Init()
 {
   // Makes all memory allocations
   fInit = kTRUE ; 
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;  
-  if ( gime == 0 ) {
-    Error("Init", "Could not obtain the Getter object for file %s and event %s !", GetTitle(), fEventFolderName.Data()) ;   
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+
+  if ( emcalLoader == 0 ) {
+    Fatal("Init", "Could not obtain the AliEMCALLoader");  
     return kFALSE;
   } 
-  
-  TString opt("Digits") ; 
-  if(gime->VersionExists(opt) ) { 
-    Error( "Init", "Give a version name different from %s", fEventFolderName.Data() ) ;
-    fInit = kFALSE ; 
-  }
 
-  // Post Digitizer to the white board
-  gime->PostDigitizer(this) ;
-  
   fFirstEvent = 0 ; 
   fLastEvent = fFirstEvent ; 
   
@@ -449,28 +484,31 @@ Bool_t AliEMCALDigitizer::Init()
   }
   
   //to prevent cleaning of this object while GetEvent is called
-  gime->EmcalLoader()->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+  emcalLoader->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
   
   return fInit ;    
 }
 
 //____________________________________________________________________________ 
 void AliEMCALDigitizer::InitParameters()
-{
-  fMeanPhotonElectron = 18200 ; // electrons per GeV
-  fPinNoise           = 0.1 ; // noise equivalent GeV (random choice)
+{ // Tune parameters - 24-nov-04
+
+  fMeanPhotonElectron = 3300 ; // electrons per GeV 
+  fPinNoise           = 0.004; 
   if (fPinNoise == 0. ) 
     Warning("InitParameters", "No noise added\n") ; 
-  fDigitThreshold     = fPinNoise * 3; //2 sigma
-  fTimeResolution     = 1.0e-9 ;
+  fDigitThreshold     = fPinNoise * 3; // 3 * sigma
+  fTimeResolution     = 0.3e-9 ; // 300 psc
   fTimeSignalLength   = 1.0e-9 ;
 
-  fADCchannelEC    = 0.00305;                     // width of one ADC channel in GeV - HG fix so that we see 200 GeV gammas
-  fADCpedestalEC   = 0.005 ;                       // GeV
-  fNADCEC          = (Int_t) TMath::Power(2,16) ;  // number of channels in Tower ADC
+  fADCchannelEC    = 0.00305; // 200./65536 - width of one ADC channel in GeV
+  fADCpedestalEC   = 0.009 ;  // GeV
+  fNADCEC          = (Int_t) TMath::Power(2,16) ;  // number of channels in Tower ADC - 65536
 
-  fTimeThreshold      = 0.001*10000000 ; //Means 1 MeV in terms of SDigits amplitude
+  fTimeThreshold      = 0.001*10000000 ; // Means 1 MeV in terms of SDigits amplitude ??
+  // hists. for control; no hists on default
+  fControlHists = 0;
+  fHists        = 0;
 }
 
 //__________________________________________________________________
@@ -501,9 +539,10 @@ void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
     return ; 
   }
   // looking for the file which contains SDigits
-  AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
-  TString fileName( gime->GetSDigitsFileName() ) ; 
-    if ( eventFolderName != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
+  //AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+  TString fileName( emcalLoader->GetSDigitsFileName() ) ; 
+    if ( eventFolderName != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
       fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
     if ( (gSystem->AccessPathName(fileName)) ) { 
       Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
@@ -524,9 +563,15 @@ void AliEMCALDigitizer::MixWith(TString alirunFileName, TString eventFolderName)
     fEventNames[fInput]     = eventFolderName ;
     fInput++ ;
 }  
+
+void AliEMCALDigitizer::Print1(Option_t * option)
+{ // 19-nov-04 - just for convinience
+  Print(); 
+  PrintDigits(option);
+}
+
 //__________________________________________________________________
-void AliEMCALDigitizer::Print()const 
+void AliEMCALDigitizer::Print(Option_t*)const 
 {
   // Print Digitizer's parameters
   printf("Print: \n------------------- %s -------------", GetName() ) ; 
@@ -540,17 +585,24 @@ void AliEMCALDigitizer::Print()const
       nStreams = fInput ; 
     
     Int_t index = 0 ;  
+
+    AliRunLoader *rl=0;
+
     for (index = 0 ; index < nStreams ; index++) {  
       TString tempo(fEventNames[index]) ; 
       tempo += index ;
-      AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[index], tempo) ; 
-      TString fileName( gime->GetSDigitsFileName() ) ; 
-      if ( fEventNames[index] != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
+      if ((rl = AliRunLoader::GetRunLoader(tempo)) == 0)
+       rl = AliRunLoader::Open(fInputFileNames[index], tempo) ; 
+      AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
+      TString fileName( emcalLoader->GetSDigitsFileName() ) ; 
+      if ( fEventNames[index] != AliConfig::GetDefaultEventFolderName()) // only if not the default folder name 
        fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index]  + ".root" ;
       printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ; 
     }
-    AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
-    printf("\nWriting digits to %s", gime->GetDigitsFileName().Data()) ;
+
+    AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+
+    printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
     
     printf("\nWith following parameters:\n") ;
     
@@ -564,13 +616,12 @@ void AliEMCALDigitizer::Print()const
 
 //__________________________________________________________________
 void AliEMCALDigitizer::PrintDigits(Option_t * option){
-    
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
-  TClonesArray * digits = gime->Digits() ;
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+  TClonesArray * digits  = emcalLoader->Digits() ;
+  TClonesArray * sdigits = emcalLoader->SDigits() ;
   
-  printf("PrintDigits: %d", digits->GetEntriesFast()) ; 
-  printf("\nevent %d", gAlice->GetEvNumber()) ;
-  printf("\n       Number of entries in Digits list %d", digits->GetEntriesFast() )  ;  
+  printf("\n #Digits: %d : sdigits %d ", digits->GetEntriesFast(), sdigits->GetEntriesFast()) ; 
+  printf("\n event %d", emcalLoader->GetRunLoader()->GetEventNumber());
   
   if(strstr(option,"all")){  
     //loop over digits
@@ -588,30 +639,32 @@ void AliEMCALDigitizer::PrintDigits(Option_t * option){
       }
     }   
   }
+  printf("\n");
 }
 
 //__________________________________________________________________
 Float_t AliEMCALDigitizer::TimeOfNoise(void)
-{  // Calculates the time signal generated by noise
-  //to be rewritten, now returns just big number
-  return 1. ;
-
+{  
+  // Calculates the time signal generated by noise
+  //PH  Info("TimeOfNoise", "Change me") ; 
+  return gRandom->Rndm() * 1.28E-5;
 }
 
 //__________________________________________________________________
 void AliEMCALDigitizer::Unload() 
 {  
   // Unloads the SDigits and Digits
+  AliRunLoader *rl=0;
+    
   Int_t i ; 
   for(i = 1 ; i < fInput ; i++){
     TString tempo(fEventNames[i]) ; 
-    tempo += i ;
-    AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ; 
-    gime->EmcalLoader()->UnloadSDigits() ; 
+    tempo += i;
+    if ((rl = AliRunLoader::GetRunLoader(tempo))) 
+      rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ; 
   }
-  
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
-  gime->EmcalLoader()->UnloadDigits() ; 
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+  emcalLoader->UnloadDigits() ; 
 }
 
 //_________________________________________________________________________________________
@@ -626,20 +679,58 @@ void AliEMCALDigitizer::WriteDigits()
   //      and branch "AliEMCALDigitizer", with the same title to keep all the parameters
   //      and names of files, from which digits are made.
 
-  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
-  const TClonesArray * digits = gime->Digits() ; 
-  TTree * treeD = gime->TreeD(); 
+  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+
+  const TClonesArray * digits = emcalLoader->Digits() ; 
+  TTree * treeD = emcalLoader->TreeD(); 
+  if ( !treeD ) {
+    emcalLoader->MakeDigitsContainer();
+    treeD = emcalLoader->TreeD(); 
+  }
 
   // -- create Digits branch
   Int_t bufferSize = 32000 ;    
-  TBranch * digitsBranch = treeD->Branch("EMCAL",&digits,bufferSize);
-  digitsBranch->SetTitle(fEventFolderName);
-  digitsBranch->Fill() ;
+  TBranch * digitsBranch = 0;
+  if ((digitsBranch = treeD->GetBranch("EMCAL")))
+    digitsBranch->SetAddress(&digits);
+  else
+    treeD->Branch("EMCAL","TClonesArray",&digits,bufferSize);
+  //digitsBranch->SetTitle(fEventFolderName);
+  treeD->Fill() ;
   
-  gime->WriteDigits("OVERWRITE");
-  gime->WriteDigitizer("OVERWRITE");
+  emcalLoader->WriteDigits("OVERWRITE");
+  emcalLoader->WriteDigitizer("OVERWRITE");
 
   Unload() ; 
 
 }
 
+void AliEMCALDigitizer::Browse(TBrowser* b)
+{
+  if(fHists) b->Add(fHists);
+  TTask::Browse(b);
+}
+
+TList *AliEMCALDigitizer::BookControlHists(int var)
+{ // 22-nov-04
+  Info("BookControlHists"," started ");
+  gROOT->cd();
+  const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
+  if(var>=1){
+    new TH1F("hDigiN",  "#EMCAL digits with fAmp > fDigitThreshold", 
+    fNADCEC+1, -0.5, Double_t(fNADCEC));
+    new TH1F("HDigiSumEnergy","Sum.EMCAL energy from digi", 1000, 0.0, 200.);
+    new TH1F("hDigiAmp",  "EMCAL digital amplitude", fNADCEC+1, -0.5, Double_t(fNADCEC));
+    new TH1F("hDigiEnergy","EMCAL cell energy", 2000, 0.0, 200.);
+    new TH1F("hDigiAbsId","EMCAL absId cells with fAmp > fDigitThreshold ",
+    geom->GetNCells(), 0.5, Double_t(geom->GetNCells())+0.5);
+  }
+  fHists = sv::MoveHistsToList("EmcalDigiControlHists", kFALSE);
+  fHists = 0;
+  return fHists;
+}
+
+void AliEMCALDigitizer::SaveHists(const char* name, Bool_t kSingleKey, const char* opt)
+{
+  sv::SaveListOfHists(fHists, name, kSingleKey, opt); 
+}