ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//_________________________________________________________________________
// 
//////////////////////////////////////////////////////////////////////////////
// Class performs digitization of Summable digits from simulated data
//  
// In addition it performs mixing/embedding of summable digits from different events.
//
// For each event 3 branches are created in TreeD:
//   "EMCAL" - list of digits
//   "EMCALTRG" - list of trigger digits
//   "AliEMCALDigitizer" - AliEMCALDigitizer with all parameters used in digitization
//
//
////////////////////////////////////////////////////////////////////////////////////
//
//*-- Author: Sahal Yacoob (LBL)
// based on : AliEMCALDigitizer
// Modif: 
//  August 2002 Yves Schutz: clone PHOS as closely as possible and intoduction
//                           of new IO (a la PHOS)
//  November 2003 Aleksei Pavlinov : adopted for Shish-Kebab geometry 
//  July 2011 GCB: Digitizer modified to accomodate embedding. 
//                 Time calibration added. Decalibration possibility of energy and time added
//_________________________________________________________________________________

// --- ROOT system ---
#include <TROOT.h>
#include <TTree.h>
#include <TSystem.h>
#include <TBenchmark.h>
#include <TBrowser.h>
#include <TObjectTable.h>
#include <TRandom.h>
#include <TF1.h>
#include <cassert>

// --- AliRoot header files ---
#include "AliLog.h"
#include "AliRun.h"
#include "AliDigitizationInput.h"
#include "AliRunLoader.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliEMCALDigit.h"
#include "AliEMCAL.h"
#include "AliEMCALLoader.h"
#include "AliEMCALDigitizer.h"
#include "AliEMCALSDigitizer.h"
#include "AliEMCALGeometry.h"
#include "AliEMCALCalibData.h"
#include "AliEMCALSimParam.h"
#include "AliEMCALRawDigit.h"
#include "AliCaloCalibPedestal.h"

  namespace
  {
    Double_t HeavisideTheta(Double_t x)
    {
      Double_t signal = 0.;
      
      if (x > 0.) signal = 1.;  
      
      return signal;  
    }
    
    Double_t AnalogFastORFunction(Double_t *x, Double_t *par)
    {
      Double_t v0 = par[0];
      Double_t t0 = par[1];
      Double_t tr = par[2];
      
      Double_t R1 = 1000.;
      Double_t C1 = 33e-12;
      Double_t R2 = 1800;
      Double_t C2 = 22e-12;
      
      Double_t t  =   x[0];
      
      return (((0.8*(-((TMath::Power(C1,2)*C2*TMath::Power(TMath::E(),(-t + t0)/(C1*R1))*
			TMath::Power(R1,2)*R2)/(C1*R1 - C2*R2)) + 
		     C1*C2*R1*R2*(1 - (C2*TMath::Power(TMath::E(),(-t + t0)/(C2*R2))*R2)/(-(C1*R1) + C2*R2)))*v0*
		HeavisideTheta(t - t0))/tr 
	       - (0.8*(C1*C2*R1*R2 - 
		       (TMath::Power(C1,2)*C2*TMath::Power(TMath::E(),(-1.*t + t0 + 1.25*tr)/(C1*R1))*
			TMath::Power(R1,2)*R2)/(C1*R1 - C2*R2) + 
		       (C1*TMath::Power(C2,2)*TMath::Power(TMath::E(),(-1.*t + t0 + 1.25*tr)/(C2*R2))*
			R1*TMath::Power(R2,2))/(C1*R1 - C2*R2))*v0*
		  HeavisideTheta(t - t0 - 1.25*tr))/tr)/(C2*R1));
    }
  }

ClassImp(AliEMCALDigitizer)
  
  
//____________________________________________________________________________ 
AliEMCALDigitizer::AliEMCALDigitizer()
  : AliDigitizer("",""),
    fDefaultInit(kTRUE),
    fDigitsInRun(0),
    fInit(0),
    fInput(0),
    fInputFileNames(0x0),
    fEventNames(0x0),
    fDigitThreshold(0),
    fMeanPhotonElectron(0),
    fGainFluctuations(0),
    fPinNoise(0),
    fTimeNoise(0),
    fTimeDelay(0),
    fTimeResolutionPar0(0),
    fTimeResolutionPar1(0),
    fADCchannelEC(0),
    fADCpedestalEC(0),
    fADCchannelECDecal(0),
    fTimeChannel(0),
    fTimeChannelDecal(0),
    fNADCEC(0),
    fEventFolderName(""),
    fFirstEvent(0),
    fLastEvent(0),
    fCalibData(0x0),
    fSDigitizer(0x0)
{
  // ctor
  InitParameters() ; 
  fDigInput = 0 ;                     // We work in the standalone mode
}

//____________________________________________________________________________ 
AliEMCALDigitizer::AliEMCALDigitizer(TString alirunFileName, TString eventFolderName)
  : AliDigitizer("EMCALDigitizer", alirunFileName),
    fDefaultInit(kFALSE),
    fDigitsInRun(0),
    fInit(0),
    fInput(0),
    fInputFileNames(0), 
    fEventNames(0), 
    fDigitThreshold(0),
    fMeanPhotonElectron(0),
    fGainFluctuations(0),
    fPinNoise(0),
    fTimeNoise(0),
    fTimeDelay(0),
    fTimeResolutionPar0(0),
    fTimeResolutionPar1(0),
    fADCchannelEC(0),
    fADCpedestalEC(0),
    fADCchannelECDecal(0),
    fTimeChannel(0),
    fTimeChannelDecal(0),
    fNADCEC(0),
    fEventFolderName(eventFolderName),
    fFirstEvent(0),
    fLastEvent(0),
    fCalibData(0x0),
    fSDigitizer(0x0)
{
  // ctor
  InitParameters() ; 
  Init() ;
  fDigInput = 0 ;                     // We work in the standalone mode
}

//____________________________________________________________________________ 
AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d) 
  : AliDigitizer(d.GetName(),d.GetTitle()),
    fDefaultInit(d.fDefaultInit),
    fDigitsInRun(d.fDigitsInRun),
    fInit(d.fInit),
    fInput(d.fInput),
    fInputFileNames(d.fInputFileNames),
    fEventNames(d.fEventNames),
    fDigitThreshold(d.fDigitThreshold),
    fMeanPhotonElectron(d.fMeanPhotonElectron),
    fGainFluctuations(d.fGainFluctuations),
    fPinNoise(d.fPinNoise),
    fTimeNoise(d.fTimeNoise),
    fTimeDelay(d.fTimeDelay),
    fTimeResolutionPar0(d.fTimeResolutionPar0),
    fTimeResolutionPar1(d.fTimeResolutionPar1),
    fADCchannelEC(d.fADCchannelEC),
    fADCpedestalEC(d.fADCpedestalEC),
    fADCchannelECDecal(d.fADCchannelECDecal),
    fTimeChannel(d.fTimeChannel), fTimeChannelDecal(d.fTimeChannelDecal),
    fNADCEC(d.fNADCEC),
    fEventFolderName(d.fEventFolderName),
    fFirstEvent(d.fFirstEvent),
    fLastEvent(d.fLastEvent),
    fCalibData(d.fCalibData),
    fSDigitizer(d.fSDigitizer ? new AliEMCALSDigitizer(*d.fSDigitizer) : 0)
{
  // copyy ctor 
}

//____________________________________________________________________________ 
AliEMCALDigitizer::AliEMCALDigitizer(AliDigitizationInput * rd)
  : AliDigitizer(rd,"EMCALDigitizer"),
    fDefaultInit(kFALSE),
    fDigitsInRun(0),
    fInit(0),
    fInput(0),
    fInputFileNames(0),
    fEventNames(0),
    fDigitThreshold(0),
    fMeanPhotonElectron(0),
    fGainFluctuations(0),
    fPinNoise(0.),
    fTimeNoise(0.),
    fTimeDelay(0.),
    fTimeResolutionPar0(0.),
    fTimeResolutionPar1(0.),
    fADCchannelEC(0),
    fADCpedestalEC(0),
    fADCchannelECDecal(0),
    fTimeChannel(0),
    fTimeChannelDecal(0),    
    fNADCEC(0),
    fEventFolderName(0),
    fFirstEvent(0),
    fLastEvent(0),
    fCalibData(0x0),
    fSDigitizer(0x0)
{
  // ctor Init() is called by RunDigitizer
  fDigInput = rd ; 
  fEventFolderName = fDigInput->GetInputFolderName(0) ;
  SetTitle(dynamic_cast<AliStream*>(fDigInput->GetInputStream(0))->GetFileName(0));
  InitParameters() ; 
}

//____________________________________________________________________________ 
  AliEMCALDigitizer::~AliEMCALDigitizer()
{
  //dtor
  delete [] fInputFileNames ; 
  delete [] fEventNames ; 
  if (fSDigitizer) delete fSDigitizer;
}

//____________________________________________________________________________
void AliEMCALDigitizer::Digitize(Int_t event)
{
  // Makes the digitization of the collected summable digits
  // for this it first creates the array of all EMCAL modules
  // filled with noise and after that adds contributions from
  // SDigits. This design helps to avoid scanning over the
  // list of digits to add  contribution of any new SDigit.
  //
  // JLK 26-Jun-2008
  // Note that SDigit energy info is stored as an amplitude, so we
  // must call the Calibrate() method of the SDigitizer to convert it
  // back to an energy in GeV before adding it to the Digit
  //
  
  AliRunLoader *rl = AliRunLoader::Instance();
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
  
  if(!emcalLoader)
  {
    AliFatal("EMCALLoader is NULL!") ;
    return; // not needed but in case coverity complains ...
  }
  
  Int_t readEvent = event ;
  if (fDigInput) // fDigInput is data member from AliDigitizer
    readEvent = dynamic_cast<AliStream*>(fDigInput->GetInputStream(0))->GetCurrentEventNumber() ;
  AliDebug(1,Form("Adding event %d from input stream 0 %s %s",
                  readEvent, GetTitle(), fEventFolderName.Data())) ;
  rl->GetEvent(readEvent);
  
  TClonesArray * digits = emcalLoader->Digits() ;
  digits->Delete() ;  //correct way to clear array when memory is
  //allocated by objects stored in array
  
  // Load Geometry
  if (!rl->GetAliRun())
  {
    AliFatal("Could not get AliRun from runLoader");
    return; // not needed but in case coverity complains ...
  }
  
  AliEMCAL * emcal  = (AliEMCAL*)rl->GetAliRun()->GetDetector("EMCAL");
  AliEMCALGeometry *geom = emcal->GetGeometry();
  static int nEMC = geom->GetNCells();//max number of digits possible
  AliDebug(1,Form("nEMC %i (number cells in EMCAL) | %s \n", nEMC, geom->GetName()));
  
  digits->Expand(nEMC) ;
  
  // RS create a digitizer on the fly
  if (!fSDigitizer) fSDigitizer = new AliEMCALSDigitizer(rl->GetFileName().Data());
  fSDigitizer->SetEventRange(0, -1) ;
  
  //-------------------------------------------------------
  //take all the inputs to add together and load the SDigits
  TObjArray * sdigArray = new TObjArray(fInput) ;
  sdigArray->AddAt(emcalLoader->SDigits(), 0) ;
  
  Int_t i ;
  Int_t embed = kFALSE;
  for(i = 1 ; i < fInput ; i++)
  {
    TString tempo(fEventNames[i]) ;
    tempo += i ;
    
    AliRunLoader *  rl2 = AliRunLoader::GetRunLoader(tempo) ;
    
    if (!rl2)
      rl2 = AliRunLoader::Open(fInputFileNames[i], tempo) ;
    
    if(!rl2)
    {
      AliFatal("Run Loader of second event not available!");
      return; // not needed but in case coverity complains ...
    }
    
    if (fDigInput)
      readEvent = dynamic_cast<AliStream*>(fDigInput->GetInputStream(i))->GetCurrentEventNumber() ;
    
    Info("Digitize", "Adding event %d from input stream %d %s %s", readEvent, i, fInputFileNames[i].Data(), tempo.Data()) ;
    
    rl2->LoadSDigits();
    //     rl2->LoadDigits();
    rl2->GetEvent(readEvent);
    
    if(!rl2->GetDetectorLoader("EMCAL"))
    {
      AliFatal("Loader of second input not found");
      return; // not needed but in case coverity complains ...
    }
    
    AliEMCALLoader *emcalLoader2 = dynamic_cast<AliEMCALLoader*>(rl2->GetDetectorLoader("EMCAL"));
    
    if(!emcalLoader2)
    {
      AliFatal("EMCAL Loader of second event not available!");
      return; // not needed but in case coverity complains ...
    }

    //Merge 2 simulated sdigits
    if(!emcalLoader2->SDigits()) continue;
    
    TClonesArray* sdigits2 = emcalLoader2->SDigits();
    sdigArray->AddAt(sdigits2, i) ;
    
    // Check if first sdigit is of embedded type, if so, handle the sdigits differently:
    // do not smear energy of embedded, do not add noise to any sdigits
    if( sdigits2->GetEntriesFast() <= 0 ) continue;
    
    //printf("Merged digit type: %d\n",dynamic_cast<AliEMCALDigit*> (sdigits2->At(0))->GetType());
    AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*> (sdigits2->At(0));
    if( digit2 && digit2->GetType()==AliEMCALDigit::kEmbedded ) embed = kTRUE;
    
  }// input loop
  
  //--------------------------------
  //Find the first tower with signal
  Int_t nextSig = nEMC + 1 ;
  TClonesArray * sdigits ;
  for(i = 0 ; i < fInput ; i++)
  {
    if(i > 0 && embed) continue;
    
    sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
    if(!sdigits)
    {
      AliDebug(1,"Null sdigit pointer");
      continue;
    }
    
    if (sdigits->GetEntriesFast() <= 0 )
    {
      AliDebug(1, "No sdigits entries");
      continue;
    }
    
    AliEMCALDigit *sd = dynamic_cast<AliEMCALDigit *>(sdigits->At(0));
    if(!sd)
    {
      AliDebug(1, "NULL sdigit pointer");
      continue;
    }
    
    Int_t curNext = sd->GetId() ;
    if(curNext < nextSig)
    nextSig = curNext ;
    AliDebug(1,Form("input %i : #sdigits %i \n",i, sdigits->GetEntriesFast()));
    
  }// input loop
  
  AliDebug(1,Form("FIRST tower with signal %i \n", nextSig));
  
  TArrayI index(fInput) ;
  index.Reset() ;  //Set all indexes to zero
  
  AliEMCALDigit * digit ;
  AliEMCALDigit * curSDigit ;
  
  //---------------------------------------------
  //Put Noise contribution, smear time and energy
  Float_t timeResolution = 0;
  Int_t absID = -1 ;
  for(absID = 0; absID < nEMC; absID++)
  {
    Float_t energy = 0 ;
    
    // amplitude set to zero, noise will be added later
    Float_t noiseTime = 0.;
    if(!embed) noiseTime = TimeOfNoise(); //No need for embedded events?
    new((*digits)[absID]) AliEMCALDigit( -1, -1, absID, 0., noiseTime,kFALSE); // absID-1->absID
    //look if we have to add signal?
    digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID)); // absID-1->absID
    
    if (!digit)
    {
      AliDebug(1,"Digit pointer is null");
      continue;
    }
    
    if(absID==nextSig)
    {
      // Calculate time as time of the largest digit
      Float_t time = digit->GetTime() ;
      Float_t aTime= digit->GetAmplitude() ;
      
      // loop over input
      Int_t nInputs = fInput;
      if(embed) nInputs = 1; // In case of embedding, merge later real digits, do not smear energy and time of data
      for(i = 0; i< nInputs ; i++)
      {
        //loop over (possible) merge sources
        TClonesArray* sdtclarr = dynamic_cast<TClonesArray *>(sdigArray->At(i));
        if(sdtclarr)
        {
          Int_t sDigitEntries = sdtclarr->GetEntriesFast();
          
          if(sDigitEntries > index[i] ) curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
          else                          curSDigit = 0 ;
          
          //May be several digits will contribute from the same input
          while(curSDigit && (curSDigit->GetId() == absID))
          {
            //Shift primary to separate primaries belonging different inputs
            Int_t primaryoffset = i ;
            if(fDigInput) primaryoffset = fDigInput->GetMask(i) ;
            curSDigit->ShiftPrimary(primaryoffset) ;
            
            if(curSDigit->GetAmplitude()>aTime)
            {
              aTime = curSDigit->GetAmplitude();
              time  = curSDigit->GetTime();
            }
            
            *digit = *digit + *curSDigit ;  //adds amplitudes of each digit
            
            index[i]++ ;
            
            if( sDigitEntries > index[i] ) curSDigit = dynamic_cast<AliEMCALDigit*>(sdtclarr->At(index[i])) ;
            else                           curSDigit = 0 ;
          }// while
        }// source exists
      }// loop over merging sources
      
      //Here we convert the summed amplitude to an energy in GeV only for simulation or mixing of simulations
      energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ; // GeV
      
      // add fluctuations for photo-electron creation
      // corrected fluctuations after comparison with beam test, Paraskevi Ganoti (06/11/2011)
      Float_t fluct = static_cast<Float_t>((energy*fMeanPhotonElectron)/fGainFluctuations);
      energy       *= static_cast<Float_t>(gRandom->Poisson(fluct)) / fluct ;
      
      //calculate and set time
      digit->SetTime(time) ;
      
      //Find next signal module
      nextSig = nEMC + 1 ;
      for(i = 0 ; i < nInputs ; i++)
      {
        sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
        
        if(sdigits)
        {
          Int_t curNext = nextSig ;
          if(sdigits->GetEntriesFast() > index[i])
          {
            AliEMCALDigit * tmpdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]));
            if ( tmpdigit ) curNext = tmpdigit->GetId() ;
          }
          
          if(curNext < nextSig) nextSig = curNext ;
        }// sdigits exist
      } // input loop
      
    }//absID==nextSig
    
    // add the noise now, no need for embedded events with real data
    if(!embed)
      energy += gRandom->Gaus(0., fPinNoise) ;
    
    // JLK 26-June-2008
    //Now digitize the energy according to the fSDigitizer method,
    //which merely converts the energy to an integer.  Later we will
    //check that the stored value matches our allowed dynamic ranges
    digit->SetAmplitude(fSDigitizer->Digitize(energy)) ;
    
    //Set time resolution with final energy
    timeResolution = GetTimeResolution(energy);
    digit->SetTime(gRandom->Gaus(digit->GetTime(),timeResolution) ) ;
    AliDebug(10,Form(" absID %5i energy %f nextSig %5i\n",
                     absID, energy, nextSig));
    //Add delay to time
    digit->SetTime(digit->GetTime()+fTimeDelay) ;
    
  } // for(absID = 0; absID < nEMC; absID++)
  
  //---------------------------------------------------------
  //Embed simulated amplitude (and time?) to real data digits
  if ( embed )
  {
    for(Int_t input = 1; input<fInput; input++)
    {
      TClonesArray *realDigits = dynamic_cast<TClonesArray*> (sdigArray->At(input));
      if(!realDigits)
      {
        AliDebug(1,"No sdigits to merge\n");
        continue;
      }
      
      for(Int_t i2 = 0 ; i2 < realDigits->GetEntriesFast() ; i2++)
      {
        AliEMCALDigit * digit2 = dynamic_cast<AliEMCALDigit*>( realDigits->At(i2) ) ;
        if ( !digit2 ) continue;
      
        digit = dynamic_cast<AliEMCALDigit*>( digits->At(digit2->GetId()) ) ;
        if ( !digit ) continue;
        
        // Put the embedded cell energy in same units as simulated sdigits -> transform to energy units
        // and multiply to get a big int.
        Float_t time2 = digit2->GetTime();
        Float_t e2    = digit2->GetAmplitude();
        CalibrateADCTime(e2,time2,digit2->GetId());
        Float_t amp2  = fSDigitizer->Digitize(e2);
        
        Float_t e0    = digit ->GetAmplitude();
        if(e0>0.01)
          AliDebug(1,Form("digit 1: Abs ID %d, amp %f, type %d, time %e; digit2: Abs ID %d, amp %f, type %d, time %e\n",
                          digit ->GetId(),digit ->GetAmplitude(), digit ->GetType(), digit->GetTime(),
                          digit2->GetId(),amp2,                   digit2->GetType(), time2           ));
        
        // Sum amplitudes, change digit amplitude
        digit->SetAmplitude( digit->GetAmplitude() + amp2);
        
        // Rough assumption, assign time of the largest of the 2 digits,
        // data or signal to the final digit.
        if(amp2 > digit->GetAmplitude())  digit->SetTime(time2);
        
        //Mark the new digit as embedded
        digit->SetType(AliEMCALDigit::kEmbedded);
        
        if(digit2->GetAmplitude()>0.01 && e0> 0.01 )
          AliDebug(1,Form("Embedded digit: Abs ID %d, amp %f, type %d\n",
                          digit->GetId(), digit->GetAmplitude(), digit->GetType()));
      }//loop digit 2
    }//input loop
  }//embed
  
  //JLK is it better to call Clear() here?
  delete sdigArray ; //We should not delete its contents
  
  //------------------------------
  //remove digits below thresholds
  // until 10-02-2010 remove digits with energy smaller than fDigitThreshold 3*fPinNoise
  // now, remove digits with Digitized ADC smaller than fDigitThreshold = 3,
  // before merge in the same loop real data digits if available
  Float_t energy = 0;
  Float_t time   = 0;
  for(i = 0 ; i < nEMC ; i++)
  {
    digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
    if ( !digit ) continue;
    
    //Then get the energy in GeV units.
    energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ;
    
    //Then digitize using the calibration constants of the ocdb
    Float_t ampADC = energy;
    DigitizeEnergyTime(ampADC, time, digit->GetId())  ;
    
    if(ampADC < fDigitThreshold || IsDead(digit->GetId()))
      digits->RemoveAt(i) ;
    
  } // digit loop
  
  digits->Compress() ;
  
  Int_t ndigits = digits->GetEntriesFast() ;
  
  //---------------------------------------------------------------
  //JLK 26-June-2008
  //After we have done the summing and digitizing to create the
  //digits, now we want to calibrate the resulting amplitude to match
  //the dynamic range of our real data.
  for (i = 0 ; i < ndigits ; i++)
  {
    digit = dynamic_cast<AliEMCALDigit *>( digits->At(i) ) ;
    if( !digit ) continue ;
    
    digit->SetIndexInList(i) ;
    
    time   = digit->GetTime();
    digit->SetTime(time);

    energy = fSDigitizer->Calibrate(digit->GetAmplitude()) ;

    Float_t ampADC = energy;
    DigitizeEnergyTime(ampADC, time, digit->GetId());
    
    digit->SetAmplitude(ampADC) ;
    // printf("digit amplitude set at end: i %d, amp %f\n",i,digit->GetAmplitude());
  }//Digit loop
  
}

//_____________________________________________________________________
void AliEMCALDigitizer::DigitizeEnergyTime(Float_t & energy, Float_t & time, const Int_t absId)
{
  // JLK 26-June-2008
  // Returns digitized value of the energy in a cell absId
  // using the calibration constants stored in the OCDB
  // or default values if no CalibData object is found.
  // This effectively converts everything to match the dynamic range
  // of the real data we will collect
  //
  // Load Geometry
  const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
  
  if (geom==0)
  {
    AliFatal("Did not get geometry from EMCALLoader");
    return;
  }
  
  Int_t iSupMod = -1;
  Int_t nModule = -1;
  Int_t nIphi   = -1;
  Int_t nIeta   = -1;
  Int_t iphi    = -1;
  Int_t ieta    = -1;
  Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
  if(!bCell)
  Error("DigitizeEnergyTime","Wrong cell id number : absId %i ", absId) ;
  geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
  
  if(fCalibData)
  {
    fADCpedestalEC     = fCalibData->GetADCpedestal     (iSupMod,ieta,iphi);
    fADCchannelEC      = fCalibData->GetADCchannel      (iSupMod,ieta,iphi);
    fADCchannelECDecal = fCalibData->GetADCchannelDecal (iSupMod,ieta,iphi);
    fTimeChannel       = fCalibData->GetTimeChannel     (iSupMod,ieta,iphi,0); // Assign bunch crossing number equal to 0 (has simulation different bunch crossings?)
    fTimeChannelDecal  = fCalibData->GetTimeChannelDecal(iSupMod,ieta,iphi);
  }
  
  //Apply calibration to get ADC counts and partial decalibration as especified in OCDB
  energy = (energy + fADCpedestalEC)/fADCchannelEC/fADCchannelECDecal   ;
  time  += fTimeChannel-fTimeChannelDecal;
  
  if ( energy > fNADCEC ) energy =  fNADCEC ;
}

//_____________________________________________________________________
void AliEMCALDigitizer::DecalibrateTrigger(AliEMCALDigit *digit)
{
  // Decalibrate, used in Trigger digits
  
  if ( !fCalibData ) return ;
  
  // Load Geometry
  const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
	
  if (!geom)
  {
    AliFatal("Did not get geometry from EMCALLoader");
    return;
  }
	
  // Recover the digit location in row-column-SM
  Int_t absId   = digit->GetId();
  Int_t iSupMod = -1;
  Int_t nModule = -1;
  Int_t nIphi   = -1;
  Int_t nIeta   = -1;
  Int_t iphi    = -1;
  Int_t ieta    = -1;
	
  Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
  if (!bCell) Error("Decalibrate","Wrong cell id number : absId %i ", absId) ;
  
  geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
	
  // Now decalibrate
  Float_t adcChannel       = fCalibData->GetADCchannel      (iSupMod,ieta,iphi);
  Float_t adcChannelOnline = fCalibData->GetADCchannelOnline(iSupMod,ieta,iphi);
  //printf("calib param for (SM%d,col%d,row%d): %1.4f - online param: %1.4f \n",iSupMod,ieta,iphi,adcChannel,adcChannelOnline);
  Float_t factor = 1./(adcChannel/adcChannelOnline);
  
  *digit = *digit * factor;
  
}

//_____________________________________________________________________
void AliEMCALDigitizer::CalibrateADCTime(Float_t & adc, Float_t & time, const Int_t absId)
{
  // Returns the energy in a cell absId with a given adc value
  // using the calibration constants stored in the OCDB. Time also corrected from parameter in OCDB
  // Used in case of embedding, transform ADC counts from real event into energy
  // so that we can add the energy of the simulated sdigits which are in energy
  // units.
  // Same as in AliEMCALClusterizer::Calibrate() but here we do not reject channels being marked as hot
  // or with time out of window
  
  // Load Geometry
  const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
  
  if (!geom)
  {
    AliFatal("Did not get geometry from EMCALLoader");
    return;
  }
  
  Int_t iSupMod = -1;
  Int_t nModule = -1;
  Int_t nIphi   = -1;
  Int_t nIeta   = -1;
  Int_t iphi    = -1;
  Int_t ieta    = -1;
  Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
  if(!bCell) Error("CalibrateADCTime","Wrong cell id number : absId %i ", absId) ;
  geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
  
  if(fCalibData)
  {
    fADCpedestalEC = fCalibData->GetADCpedestal(iSupMod,ieta,iphi);
    fADCchannelEC  = fCalibData->GetADCchannel (iSupMod,ieta,iphi);
    fTimeChannel   = fCalibData->GetTimeChannel(iSupMod,ieta,iphi,0);// Assign bunch crossing number equal to 0 (has simulation different bunch crossings?)
  }
  
  adc   = adc * fADCchannelEC - fADCpedestalEC;
  time -= fTimeChannel;
  
}


//____________________________________________________________________________
void AliEMCALDigitizer::Digitize(Option_t *option)
{
  // Steering method to process digitization for events
  // in the range from fFirstEvent to fLastEvent.
  // This range is optionally set by SetEventRange().
  // if fLastEvent=-1, then process events until the end.
  // by default fLastEvent = fFirstEvent (process only one event)
  
  if (!fInit)
  { // to prevent overwrite existing file
    Error( "Digitize", "Give a version name different from %s", fEventFolderName.Data() ) ;
    return ;
  }
  
  if (strstr(option,"print"))
  {
    Print();
    return ;
  }
  
  if(strstr(option,"tim"))
    gBenchmark->Start("EMCALDigitizer");
  
  AliRunLoader *rl = AliRunLoader::Instance();
  
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
  if(!emcalLoader)
  {
    AliFatal("Did not get the  Loader");
    return; // coverity
  }
  
  if (fLastEvent == -1)
    fLastEvent = rl->GetNumberOfEvents() - 1 ;
  else if (fDigInput)
    fLastEvent = fFirstEvent ; // what is this ??
  
  Int_t nEvents = fLastEvent - fFirstEvent + 1;
  Int_t ievent  = -1;
  
  AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
  if(!emcal)
  {
    AliFatal("Did not get the AliEMCAL pointer");
    return; // coverity
  }
  
  AliEMCALGeometry *geom = emcal->GetGeometry();
  if(!geom)
  {
    AliFatal("Geometry pointer null");
    return; // fix for coverity
  }
  
  const Int_t nTRU = geom->GetNTotalTRU();
  TClonesArray* digitsTMP = new TClonesArray("AliEMCALDigit",    nTRU*96);
  TClonesArray* digitsTRG = new TClonesArray("AliEMCALRawDigit", nTRU*96);
  
  rl->LoadSDigits("EMCAL");
  for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++)
  {
    rl->GetEvent(ievent);
    
    Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
    
    WriteDigits() ;
    
    //Trigger Digits
    //-------------------------------------
    
    Digits2FastOR(digitsTMP, digitsTRG);
    
    WriteDigits(digitsTRG);
    
    (emcalLoader->TreeD())->Fill();
    
    emcalLoader->WriteDigits(   "OVERWRITE");
    
    Unload();
    
    digitsTRG  ->Delete();
    digitsTMP  ->Delete();
    
    //-------------------------------------
    
    if(strstr(option,"deb"))
      PrintDigits(option);
    if(strstr(option,"table")) gObjectTable->Print();
    
    //increment the total number of Digits per run
    fDigitsInRun += emcalLoader->Digits()->GetEntriesFast() ;
  }//loop
  
  if(strstr(option,"tim"))
  {
    gBenchmark->Stop("EMCALDigitizer");
    Float_t cputime   = gBenchmark->GetCpuTime("EMCALDigitizer");
    Float_t avcputime = cputime;
    if(nEvents==0) avcputime = 0 ;
    AliInfo(Form("Digitize: took %f seconds for Digitizing %f seconds per event", cputime, avcputime)) ;
  }
}

//__________________________________________________________________
Float_t AliEMCALDigitizer::GetTimeResolution(Float_t energy) const
{  
  // Assign a smeared time to the digit, from observed distribution in LED system (?).
  // From F. Blanco
  Float_t res = -1;
  if (energy > 0)
  {
    res = TMath::Sqrt(fTimeResolutionPar0 + 
		      fTimeResolutionPar1/(energy*energy) );
  }
  // parametrization above is for ns. Convert to seconds:
  return res*1e-9;
}

//____________________________________________________________________________
void AliEMCALDigitizer::Digits2FastOR(TClonesArray* digitsTMP, TClonesArray* digitsTRG)
{
  // FEE digits afterburner to produce TRG digits
  // we are only interested in the FEE digit deposited energy
  // to be converted later into a voltage value
  
  // push the FEE digit to its associated FastOR (numbered from 0:95)
  // TRU is in charge of summing module digits
  
  AliRunLoader *runLoader = AliRunLoader::Instance();
  
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
  if (!emcalLoader) AliFatal("Did not get the  Loader");
  
  const  AliEMCALGeometry* geom = AliEMCALGeometry::GetInstance();
  if(!geom)
  {
    AliFatal("Geometry pointer null");
    return; // fix for coverity
  }
  
  // build FOR from simulated digits
  // and xfer to the corresponding TRU input (mapping)
  
  TClonesArray* sdigits = emcalLoader->SDigits();
  
  TClonesArray *digits = (TClonesArray*)sdigits->Clone();
  
  AliDebug(999,Form("=== %d SDigits to trigger digits ===",digits->GetEntriesFast()));
  
  TIter NextDigit(digits);
  while (AliEMCALDigit* digit = (AliEMCALDigit*)NextDigit())
  {
    if (IsDead(digit)) continue;
    
    DecalibrateTrigger(digit);
    
    Int_t id = digit->GetId();
    
    Int_t trgid;
    if (geom->GetFastORIndexFromCellIndex(id , trgid))
    {
      AliDebug(1,Form("trigger digit id: %d from cell id: %d\n",trgid,id));
      
      AliEMCALDigit* d = static_cast<AliEMCALDigit*>(digitsTMP->At(trgid));
      
      if (!d)
      {
        new((*digitsTMP)[trgid]) AliEMCALDigit(*digit);
        d = (AliEMCALDigit*)digitsTMP->At(trgid);
        d->SetId(trgid);
      }
      else
      {
        *d = *d + *digit;
      }
    }
  }
  
  if (AliDebugLevel()) printf("Number of TRG digits: %d\n",digitsTMP->GetEntriesFast());
  
  Int_t     nSamples = geom->GetNTotalTRU();
  Int_t *timeSamples = new Int_t[nSamples];
  
  NextDigit = TIter(digitsTMP);
  while (AliEMCALDigit* digit = (AliEMCALDigit*)NextDigit())
  {
    if (digit)
    {
      Int_t     id = digit->GetId();
      Float_t time = 50.e-9;
      
      Double_t depositedEnergy = 0.;
      for (Int_t j = 1; j <= digit->GetNprimary(); j++) depositedEnergy += digit->GetDEPrimary(j);
      
      if (AliDebugLevel()) printf("Deposited Energy: %f\n", depositedEnergy);
      
      // FIXME: Check digit time!
      if (depositedEnergy) {
        depositedEnergy += gRandom->Gaus(0., .08);
        DigitalFastOR(time, depositedEnergy, timeSamples, nSamples);
        
        for (Int_t j=0;j<nSamples;j++) {
          if (AliDebugLevel()) printf("timeSamples[%d]: %d\n",j,timeSamples[j]);
          timeSamples[j] = ((j << 16) | (timeSamples[j] & 0xFFFF));
        }
        
        new((*digitsTRG)[digitsTRG->GetEntriesFast()]) AliEMCALRawDigit(id, timeSamples, nSamples);
        
        if (AliDebugLevel()) ((AliEMCALRawDigit*)digitsTRG->At(digitsTRG->GetEntriesFast() - 1))->Print("");
      }
    }
  }
  
  delete [] timeSamples;
  
  if (digits && digits->GetEntriesFast()) digits->Delete();
}

//____________________________________________________________________________
void AliEMCALDigitizer::DigitalFastOR( Double_t time, Double_t dE, Int_t timeSamples[], Int_t nSamples )
{
  // parameters:
  // id: 0..95
  const Int_t    reso = 12;      // 11-bit resolution ADC
  const Double_t vFSR = 2.;      // Full scale input voltage range 2V (p-p)
//const Double_t dNe  = 125;     // signal of the APD per MeV of energy deposit in a tower: 125 photo-e-/MeV @ M=30
  const Double_t dNe  = 125/1.3; // F-ALTRO max V. FEE: factor 4
  const Double_t vA   = .136e-6; // CSP output range: 0.136uV/e-
  const Double_t rise = 50e-9;   // rise time (10-90%) of the FastOR signal before shaping
	
  const Double_t kTimeBinWidth = 25E-9; // sampling frequency (40MHz)
	
  Double_t vV = 1000. * dE * dNe * vA; // GeV 2 MeV
  
  TF1 signalF("signal", AnalogFastORFunction, 0, nSamples * kTimeBinWidth, 3);
  signalF.SetParameter( 0,   vV );
  signalF.SetParameter( 1, time ); // FIXME: when does the signal arrive? Might account for cable lengths
  signalF.SetParameter( 2, rise );
	
  for (Int_t iTime=0; iTime<nSamples; iTime++)
  {
    // FIXME: add noise (probably not simply Gaussian) according to DA measurements
    // probably plan an access to OCDB
    Double_t sig = signalF.Eval(iTime * kTimeBinWidth);
    if (TMath::Abs(sig) > vFSR/2.) {
      AliError("Signal overflow!");
      timeSamples[iTime] = (1 << reso) - 1;
    } else {
      AliDebug(999,Form("iTime: %d sig: %f\n",iTime,sig));
      timeSamples[iTime] = ((1 << reso) / vFSR) * sig + 0.5;
    }
  }
}

//____________________________________________________________________________ 
Bool_t AliEMCALDigitizer::Init()
{
  // Makes all memory allocations
  fInit = kTRUE ; 
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
  
  if ( emcalLoader == 0 ) {
    Fatal("Init", "Could not obtain the AliEMCALLoader");  
    return kFALSE;
  } 
  
  fFirstEvent = 0 ; 
  fLastEvent = fFirstEvent ; 
  
  if(fDigInput)
    fInput = fDigInput->GetNinputs() ; 
  else 
    fInput           = 1 ;

  fInputFileNames  = new TString[fInput] ; 
  fEventNames      = new TString[fInput] ; 
  fInputFileNames[0] = GetTitle() ; 
  fEventNames[0]     = fEventFolderName.Data() ; 
  Int_t index ; 
  for (index = 1 ; index < fInput ; index++) {
    fInputFileNames[index] = dynamic_cast<AliStream*>(fDigInput->GetInputStream(index))->GetFileName(0); 
    TString tempo = fDigInput->GetInputFolderName(index) ;
    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fDigInput 
  }
    
  //Calibration instance
  fCalibData = emcalLoader->CalibData();
  return fInit ;    
}

//____________________________________________________________________________ 
void AliEMCALDigitizer::InitParameters()
{ 
  // Parameter initialization for digitizer
  
  // Get the parameters from the OCDB via the loader
  AliRunLoader *rl = AliRunLoader::Instance();
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
  AliEMCALSimParam * simParam = 0x0;
  if(emcalLoader) simParam = emcalLoader->SimulationParameters();
	
  if(!simParam){
    simParam = AliEMCALSimParam::GetInstance();
    AliWarning("Simulation Parameters not available in OCDB?");
  }
  
  fMeanPhotonElectron = simParam->GetMeanPhotonElectron() ; // 4400;  // electrons per GeV 
  fGainFluctuations   = simParam->GetGainFluctuations()   ; // 15.0; 
  
  fPinNoise           = simParam->GetPinNoise();//0.012; // pin noise in GeV from analysis test beam data 
  if (fPinNoise < 0.0001 ) 
    Warning("InitParameters", "No noise added\n") ; 
  fTimeNoise          = simParam->GetTimeNoise(); // 1.28E-5 s
  fDigitThreshold     = simParam->GetDigitThreshold(); //fPinNoise * 3; // 3 * sigma
  fTimeResolutionPar0 = simParam->GetTimeResolutionPar0(); 
  fTimeResolutionPar1 = simParam->GetTimeResolutionPar1(); 
  fTimeDelay          = simParam->GetTimeDelay(); //600e-9 ; // 600 ns
  
  // These defaults are normally not used. 
  // Values are read from calibration database instead
  fADCchannelEC       = 0.0162; // Nominal value set online for most of the channels, MIP peak sitting at ~266./16/1024
  fADCpedestalEC      = 0.0 ;   // GeV
  fADCchannelECDecal  = 1.0;    // No decalibration by default
  fTimeChannel        = 0.0;    // No time calibration by default
  fTimeChannelDecal   = 0.0;    // No time decalibration by default

  fNADCEC             = simParam->GetNADCEC();//(Int_t) TMath::Power(2,16) ;  // number of channels in Tower ADC - 65536
  
  AliDebug(2,Form("Mean Photon Electron %d, Gain Fluct. %2.1f; Noise: APD %f, Time %f; Digit Threshold %d,Time Resolution Par0 %g Par1 %g,NADCEC %d",
                  fMeanPhotonElectron, fGainFluctuations, fPinNoise,fTimeNoise, fDigitThreshold,fTimeResolutionPar0,fTimeResolutionPar1,fNADCEC));
  
}

//__________________________________________________________________
void AliEMCALDigitizer::Print1(Option_t * option)
{ // 19-nov-04 - just for convenience
  Print(); 
  PrintDigits(option);
}

//__________________________________________________________________
void AliEMCALDigitizer::Print (Option_t * ) const
{
  // Print Digitizer's parameters
  printf("Print: \n------------------- %s -------------", GetName() ) ; 
  if( strcmp(fEventFolderName.Data(), "") != 0 ){
    printf(" Writing Digits to branch with title  %s\n", fEventFolderName.Data()) ;
    
    Int_t nStreams ; 
    if (fDigInput) 
      nStreams =  GetNInputStreams() ;
    else 
      nStreams = fInput ; 
    
    AliRunLoader *rl=0;
    
    Int_t index = 0 ;  
    for (index = 0 ; index < nStreams ; index++) {  
      TString tempo(fEventNames[index]) ; 
      tempo += index ;
      if ((rl = AliRunLoader::GetRunLoader(tempo)) == 0)
        rl = AliRunLoader::Open(fInputFileNames[index], tempo) ; 
      AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
      if(emcalLoader){
        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()) ; 
      }//loader
    }
    
    AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
    
    if(emcalLoader) printf("\nWriting digits to %s", emcalLoader->GetDigitsFileName().Data()) ;
    else printf("\nNULL LOADER");
    
    printf("\nWith following parameters:\n") ;
    printf("    Electronics noise in EMC, APD (fPinNoise) = %f, Time = %f \n", fPinNoise, fTimeNoise) ;
    printf("    Threshold  in Tower  (fDigitThreshold) = %d\n", fDigitThreshold)  ;
    printf("---------------------------------------------------\n")  ;
  }
  else
    printf("Print: AliEMCALDigitizer not initialized") ; 
}

//__________________________________________________________________
void AliEMCALDigitizer::PrintDigits(Option_t * option)
{
  //utility method for printing digit information
  
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
  if(emcalLoader){
    TClonesArray * digits  = emcalLoader->Digits() ;
    TClonesArray * sdigits = emcalLoader->SDigits() ;
    
    printf("\n #Digits: %d : sdigits %d ", digits->GetEntriesFast(), sdigits->GetEntriesFast()) ; 
    printf("\n event %d", emcalLoader->GetRunLoader()->GetEventNumber());
    
    if(strstr(option,"all")){  
      //loop over digits
      AliEMCALDigit * digit;
      printf("\nEMC digits (with primaries):\n")  ;
      printf("\n   Id  Amplitude    Time          Index Nprim: Primaries list \n") ;    
      Int_t index ;
      for (index = 0 ; index < digits->GetEntries() ; index++) {
        digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
        if(digit){
          printf("\n%6d  %8f    %6.5e %4d      %2d : ",
                 digit->GetId(), digit->GetAmplitude(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;  
          Int_t iprimary;
          for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
            printf("%d ",digit->GetPrimary(iprimary+1) ) ; 
          }
        }// digit exists
      }// loop
    }
    printf("\n");
  }// loader exists
  else printf("NULL LOADER, cannot print\n");
}

//__________________________________________________________________
Float_t AliEMCALDigitizer::TimeOfNoise(void)
{  
  // Calculates the time signal generated by noise
  //printf("Time noise %e\n",fTimeNoise);
  return gRandom->Rndm() * fTimeNoise;
}

//__________________________________________________________________
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;
    if ((rl = AliRunLoader::GetRunLoader(tempo))) 
      rl->GetDetectorLoader("EMCAL")->UnloadSDigits() ; 
  }
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
  if(emcalLoader)emcalLoader->UnloadDigits() ; 
  else AliFatal("Did not get the loader");
}

//_________________________________________________________________________________________
void AliEMCALDigitizer::WriteDigits()
{ // Makes TreeD in the output file. 
  // Check if branch already exists: 
  //   if yes, exit without writing: ROOT TTree does not support overwriting/updating of 
  //      already existing branches. 
  //   else creates branch with Digits, named "EMCAL", title "...",
  //      and branch "AliEMCALDigitizer", with the same title to keep all the parameters
  //      and names of files, from which digits are made.
  
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
  
  if(emcalLoader){
    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 = 0;
    if ((digitsBranch = treeD->GetBranch("EMCAL"))) {
      digitsBranch->SetAddress(&digits);
      AliWarning("Digits Branch already exists. Not all digits will be visible");
    }
    else
      treeD->Branch("EMCAL","TClonesArray",&digits,bufferSize);
    //digitsBranch->SetTitle(fEventFolderName);
    
    //	treeD->Fill() ;
    /*  
     emcalLoader->WriteDigits("OVERWRITE");
     emcalLoader->WriteDigitizer("OVERWRITE");
     
     Unload() ; 
     */
    
  }// loader exists
  else AliFatal("Loader not available");
}

//__________________________________________________________________
void AliEMCALDigitizer::WriteDigits(TClonesArray* digits, const char* branchName)
{
  // overloaded method
  AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::Instance()->GetDetectorLoader("EMCAL"));
  if(emcalLoader){
    
    TTree* treeD = emcalLoader->TreeD(); 
    if (!treeD) 
      {
	emcalLoader->MakeDigitsContainer();
	treeD = emcalLoader->TreeD(); 
      }
    
    // -- create Digits branch
    Int_t bufferSize = 32000;
    
    if (TBranch* triggerBranch = treeD->GetBranch(branchName)) 
      {
	triggerBranch->SetAddress(&digits);
      }
    else
      {
	treeD->Branch(branchName,"TClonesArray",&digits,bufferSize);
      }
    
    //	treeD->Fill();
  }// loader exists
  else AliFatal("Loader not available");
}

//__________________________________________________________________
Bool_t AliEMCALDigitizer::IsDead(AliEMCALDigit *digit) 
{
  // Check if cell is defined as dead, so that it is not included
  // input is digit
  Int_t absId   = digit->GetId();

  return IsDead(absId);
  
}


//__________________________________________________________________
Bool_t AliEMCALDigitizer::IsDead(Int_t absId)
{
  // Check if cell absID is defined as dead, so that it is not included

    AliRunLoader *runLoader = AliRunLoader::Instance();
    AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
    if (!emcalLoader)
    {
      AliFatal("Did not get the  Loader");
      return kTRUE;
    }
  
    AliCaloCalibPedestal *caloPed = emcalLoader->PedestalData();
    if (!caloPed)
    {
        AliWarning("Could not access pedestal data! No dead channel removal applied");
        return kFALSE;
    }
    
	// Load Geometry
    const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
    if (!geom)
    {
      AliFatal("Did not get geometry from EMCALLoader");
      return kTRUE; //coverity
    }
  
    Int_t iSupMod = -1;
    Int_t nModule = -1;
    Int_t nIphi   = -1;
    Int_t nIeta   = -1;
    Int_t iphi    = -1;
    Int_t ieta    = -1;
	
    Bool_t bCell = geom->GetCellIndex(absId, iSupMod, nModule, nIphi, nIeta) ;
	
    if (!bCell) Error("IsDead","Wrong cell id number : absId %i ", absId) ;
    geom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
    
    Int_t channelStatus = (Int_t)(caloPed->GetDeadMap(iSupMod))->GetBinContent(ieta,iphi);
    
    if (channelStatus == AliCaloCalibPedestal::kDead)
        return kTRUE;
    else
        return kFALSE;
}

 AliEMCALDigitizer.cxx:1
 AliEMCALDigitizer.cxx:2
 AliEMCALDigitizer.cxx:3
 AliEMCALDigitizer.cxx:4
 AliEMCALDigitizer.cxx:5
 AliEMCALDigitizer.cxx:6
 AliEMCALDigitizer.cxx:7
 AliEMCALDigitizer.cxx:8
 AliEMCALDigitizer.cxx:9
 AliEMCALDigitizer.cxx:10
 AliEMCALDigitizer.cxx:11
 AliEMCALDigitizer.cxx:12
 AliEMCALDigitizer.cxx:13
 AliEMCALDigitizer.cxx:14
 AliEMCALDigitizer.cxx:15
 AliEMCALDigitizer.cxx:16
 AliEMCALDigitizer.cxx:17
 AliEMCALDigitizer.cxx:18
 AliEMCALDigitizer.cxx:19
 AliEMCALDigitizer.cxx:20
 AliEMCALDigitizer.cxx:21
 AliEMCALDigitizer.cxx:22
 AliEMCALDigitizer.cxx:23
 AliEMCALDigitizer.cxx:24
 AliEMCALDigitizer.cxx:25
 AliEMCALDigitizer.cxx:26
 AliEMCALDigitizer.cxx:27
 AliEMCALDigitizer.cxx:28
 AliEMCALDigitizer.cxx:29
 AliEMCALDigitizer.cxx:30
 AliEMCALDigitizer.cxx:31
 AliEMCALDigitizer.cxx:32
 AliEMCALDigitizer.cxx:33
 AliEMCALDigitizer.cxx:34
 AliEMCALDigitizer.cxx:35
 AliEMCALDigitizer.cxx:36
 AliEMCALDigitizer.cxx:37
 AliEMCALDigitizer.cxx:38
 AliEMCALDigitizer.cxx:39
 AliEMCALDigitizer.cxx:40
 AliEMCALDigitizer.cxx:41
 AliEMCALDigitizer.cxx:42
 AliEMCALDigitizer.cxx:43
 AliEMCALDigitizer.cxx:44
 AliEMCALDigitizer.cxx:45
 AliEMCALDigitizer.cxx:46
 AliEMCALDigitizer.cxx:47
 AliEMCALDigitizer.cxx:48
 AliEMCALDigitizer.cxx:49
 AliEMCALDigitizer.cxx:50
 AliEMCALDigitizer.cxx:51
 AliEMCALDigitizer.cxx:52
 AliEMCALDigitizer.cxx:53
 AliEMCALDigitizer.cxx:54
 AliEMCALDigitizer.cxx:55
 AliEMCALDigitizer.cxx:56
 AliEMCALDigitizer.cxx:57
 AliEMCALDigitizer.cxx:58
 AliEMCALDigitizer.cxx:59
 AliEMCALDigitizer.cxx:60
 AliEMCALDigitizer.cxx:61
 AliEMCALDigitizer.cxx:62
 AliEMCALDigitizer.cxx:63
 AliEMCALDigitizer.cxx:64
 AliEMCALDigitizer.cxx:65
 AliEMCALDigitizer.cxx:66
 AliEMCALDigitizer.cxx:67
 AliEMCALDigitizer.cxx:68
 AliEMCALDigitizer.cxx:69
 AliEMCALDigitizer.cxx:70
 AliEMCALDigitizer.cxx:71
 AliEMCALDigitizer.cxx:72
 AliEMCALDigitizer.cxx:73
 AliEMCALDigitizer.cxx:74
 AliEMCALDigitizer.cxx:75
 AliEMCALDigitizer.cxx:76
 AliEMCALDigitizer.cxx:77
 AliEMCALDigitizer.cxx:78
 AliEMCALDigitizer.cxx:79
 AliEMCALDigitizer.cxx:80
 AliEMCALDigitizer.cxx:81
 AliEMCALDigitizer.cxx:82
 AliEMCALDigitizer.cxx:83
 AliEMCALDigitizer.cxx:84
 AliEMCALDigitizer.cxx:85
 AliEMCALDigitizer.cxx:86
 AliEMCALDigitizer.cxx:87
 AliEMCALDigitizer.cxx:88
 AliEMCALDigitizer.cxx:89
 AliEMCALDigitizer.cxx:90
 AliEMCALDigitizer.cxx:91
 AliEMCALDigitizer.cxx:92
 AliEMCALDigitizer.cxx:93
 AliEMCALDigitizer.cxx:94
 AliEMCALDigitizer.cxx:95
 AliEMCALDigitizer.cxx:96
 AliEMCALDigitizer.cxx:97
 AliEMCALDigitizer.cxx:98
 AliEMCALDigitizer.cxx:99
 AliEMCALDigitizer.cxx:100
 AliEMCALDigitizer.cxx:101
 AliEMCALDigitizer.cxx:102
 AliEMCALDigitizer.cxx:103
 AliEMCALDigitizer.cxx:104
 AliEMCALDigitizer.cxx:105
 AliEMCALDigitizer.cxx:106
 AliEMCALDigitizer.cxx:107
 AliEMCALDigitizer.cxx:108
 AliEMCALDigitizer.cxx:109
 AliEMCALDigitizer.cxx:110
 AliEMCALDigitizer.cxx:111
 AliEMCALDigitizer.cxx:112
 AliEMCALDigitizer.cxx:113
 AliEMCALDigitizer.cxx:114
 AliEMCALDigitizer.cxx:115
 AliEMCALDigitizer.cxx:116
 AliEMCALDigitizer.cxx:117
 AliEMCALDigitizer.cxx:118
 AliEMCALDigitizer.cxx:119
 AliEMCALDigitizer.cxx:120
 AliEMCALDigitizer.cxx:121
 AliEMCALDigitizer.cxx:122
 AliEMCALDigitizer.cxx:123
 AliEMCALDigitizer.cxx:124
 AliEMCALDigitizer.cxx:125
 AliEMCALDigitizer.cxx:126
 AliEMCALDigitizer.cxx:127
 AliEMCALDigitizer.cxx:128
 AliEMCALDigitizer.cxx:129
 AliEMCALDigitizer.cxx:130
 AliEMCALDigitizer.cxx:131
 AliEMCALDigitizer.cxx:132
 AliEMCALDigitizer.cxx:133
 AliEMCALDigitizer.cxx:134
 AliEMCALDigitizer.cxx:135
 AliEMCALDigitizer.cxx:136
 AliEMCALDigitizer.cxx:137
 AliEMCALDigitizer.cxx:138
 AliEMCALDigitizer.cxx:139
 AliEMCALDigitizer.cxx:140
 AliEMCALDigitizer.cxx:141
 AliEMCALDigitizer.cxx:142
 AliEMCALDigitizer.cxx:143
 AliEMCALDigitizer.cxx:144
 AliEMCALDigitizer.cxx:145
 AliEMCALDigitizer.cxx:146
 AliEMCALDigitizer.cxx:147
 AliEMCALDigitizer.cxx:148
 AliEMCALDigitizer.cxx:149
 AliEMCALDigitizer.cxx:150
 AliEMCALDigitizer.cxx:151
 AliEMCALDigitizer.cxx:152
 AliEMCALDigitizer.cxx:153
 AliEMCALDigitizer.cxx:154
 AliEMCALDigitizer.cxx:155
 AliEMCALDigitizer.cxx:156
 AliEMCALDigitizer.cxx:157
 AliEMCALDigitizer.cxx:158
 AliEMCALDigitizer.cxx:159
 AliEMCALDigitizer.cxx:160
 AliEMCALDigitizer.cxx:161
 AliEMCALDigitizer.cxx:162
 AliEMCALDigitizer.cxx:163
 AliEMCALDigitizer.cxx:164
 AliEMCALDigitizer.cxx:165
 AliEMCALDigitizer.cxx:166
 AliEMCALDigitizer.cxx:167
 AliEMCALDigitizer.cxx:168
 AliEMCALDigitizer.cxx:169
 AliEMCALDigitizer.cxx:170
 AliEMCALDigitizer.cxx:171
 AliEMCALDigitizer.cxx:172
 AliEMCALDigitizer.cxx:173
 AliEMCALDigitizer.cxx:174
 AliEMCALDigitizer.cxx:175
 AliEMCALDigitizer.cxx:176
 AliEMCALDigitizer.cxx:177
 AliEMCALDigitizer.cxx:178
 AliEMCALDigitizer.cxx:179
 AliEMCALDigitizer.cxx:180
 AliEMCALDigitizer.cxx:181
 AliEMCALDigitizer.cxx:182
 AliEMCALDigitizer.cxx:183
 AliEMCALDigitizer.cxx:184
 AliEMCALDigitizer.cxx:185
 AliEMCALDigitizer.cxx:186
 AliEMCALDigitizer.cxx:187
 AliEMCALDigitizer.cxx:188
 AliEMCALDigitizer.cxx:189
 AliEMCALDigitizer.cxx:190
 AliEMCALDigitizer.cxx:191
 AliEMCALDigitizer.cxx:192
 AliEMCALDigitizer.cxx:193
 AliEMCALDigitizer.cxx:194
 AliEMCALDigitizer.cxx:195
 AliEMCALDigitizer.cxx:196
 AliEMCALDigitizer.cxx:197
 AliEMCALDigitizer.cxx:198
 AliEMCALDigitizer.cxx:199
 AliEMCALDigitizer.cxx:200
 AliEMCALDigitizer.cxx:201
 AliEMCALDigitizer.cxx:202
 AliEMCALDigitizer.cxx:203
 AliEMCALDigitizer.cxx:204
 AliEMCALDigitizer.cxx:205
 AliEMCALDigitizer.cxx:206
 AliEMCALDigitizer.cxx:207
 AliEMCALDigitizer.cxx:208
 AliEMCALDigitizer.cxx:209
 AliEMCALDigitizer.cxx:210
 AliEMCALDigitizer.cxx:211
 AliEMCALDigitizer.cxx:212
 AliEMCALDigitizer.cxx:213
 AliEMCALDigitizer.cxx:214
 AliEMCALDigitizer.cxx:215
 AliEMCALDigitizer.cxx:216
 AliEMCALDigitizer.cxx:217
 AliEMCALDigitizer.cxx:218
 AliEMCALDigitizer.cxx:219
 AliEMCALDigitizer.cxx:220
 AliEMCALDigitizer.cxx:221
 AliEMCALDigitizer.cxx:222
 AliEMCALDigitizer.cxx:223
 AliEMCALDigitizer.cxx:224
 AliEMCALDigitizer.cxx:225
 AliEMCALDigitizer.cxx:226
 AliEMCALDigitizer.cxx:227
 AliEMCALDigitizer.cxx:228
 AliEMCALDigitizer.cxx:229
 AliEMCALDigitizer.cxx:230
 AliEMCALDigitizer.cxx:231
 AliEMCALDigitizer.cxx:232
 AliEMCALDigitizer.cxx:233
 AliEMCALDigitizer.cxx:234
 AliEMCALDigitizer.cxx:235
 AliEMCALDigitizer.cxx:236
 AliEMCALDigitizer.cxx:237
 AliEMCALDigitizer.cxx:238
 AliEMCALDigitizer.cxx:239
 AliEMCALDigitizer.cxx:240
 AliEMCALDigitizer.cxx:241
 AliEMCALDigitizer.cxx:242
 AliEMCALDigitizer.cxx:243
 AliEMCALDigitizer.cxx:244
 AliEMCALDigitizer.cxx:245
 AliEMCALDigitizer.cxx:246
 AliEMCALDigitizer.cxx:247
 AliEMCALDigitizer.cxx:248
 AliEMCALDigitizer.cxx:249
 AliEMCALDigitizer.cxx:250
 AliEMCALDigitizer.cxx:251
 AliEMCALDigitizer.cxx:252
 AliEMCALDigitizer.cxx:253
 AliEMCALDigitizer.cxx:254
 AliEMCALDigitizer.cxx:255
 AliEMCALDigitizer.cxx:256
 AliEMCALDigitizer.cxx:257
 AliEMCALDigitizer.cxx:258
 AliEMCALDigitizer.cxx:259
 AliEMCALDigitizer.cxx:260
 AliEMCALDigitizer.cxx:261
 AliEMCALDigitizer.cxx:262
 AliEMCALDigitizer.cxx:263
 AliEMCALDigitizer.cxx:264
 AliEMCALDigitizer.cxx:265
 AliEMCALDigitizer.cxx:266
 AliEMCALDigitizer.cxx:267
 AliEMCALDigitizer.cxx:268
 AliEMCALDigitizer.cxx:269
 AliEMCALDigitizer.cxx:270
 AliEMCALDigitizer.cxx:271
 AliEMCALDigitizer.cxx:272
 AliEMCALDigitizer.cxx:273
 AliEMCALDigitizer.cxx:274
 AliEMCALDigitizer.cxx:275
 AliEMCALDigitizer.cxx:276
 AliEMCALDigitizer.cxx:277
 AliEMCALDigitizer.cxx:278
 AliEMCALDigitizer.cxx:279
 AliEMCALDigitizer.cxx:280
 AliEMCALDigitizer.cxx:281
 AliEMCALDigitizer.cxx:282
 AliEMCALDigitizer.cxx:283
 AliEMCALDigitizer.cxx:284
 AliEMCALDigitizer.cxx:285
 AliEMCALDigitizer.cxx:286
 AliEMCALDigitizer.cxx:287
 AliEMCALDigitizer.cxx:288
 AliEMCALDigitizer.cxx:289
 AliEMCALDigitizer.cxx:290
 AliEMCALDigitizer.cxx:291
 AliEMCALDigitizer.cxx:292
 AliEMCALDigitizer.cxx:293
 AliEMCALDigitizer.cxx:294
 AliEMCALDigitizer.cxx:295
 AliEMCALDigitizer.cxx:296
 AliEMCALDigitizer.cxx:297
 AliEMCALDigitizer.cxx:298
 AliEMCALDigitizer.cxx:299
 AliEMCALDigitizer.cxx:300
 AliEMCALDigitizer.cxx:301
 AliEMCALDigitizer.cxx:302
 AliEMCALDigitizer.cxx:303
 AliEMCALDigitizer.cxx:304
 AliEMCALDigitizer.cxx:305
 AliEMCALDigitizer.cxx:306
 AliEMCALDigitizer.cxx:307
 AliEMCALDigitizer.cxx:308
 AliEMCALDigitizer.cxx:309
 AliEMCALDigitizer.cxx:310
 AliEMCALDigitizer.cxx:311
 AliEMCALDigitizer.cxx:312
 AliEMCALDigitizer.cxx:313
 AliEMCALDigitizer.cxx:314
 AliEMCALDigitizer.cxx:315
 AliEMCALDigitizer.cxx:316
 AliEMCALDigitizer.cxx:317
 AliEMCALDigitizer.cxx:318
 AliEMCALDigitizer.cxx:319
 AliEMCALDigitizer.cxx:320
 AliEMCALDigitizer.cxx:321
 AliEMCALDigitizer.cxx:322
 AliEMCALDigitizer.cxx:323
 AliEMCALDigitizer.cxx:324
 AliEMCALDigitizer.cxx:325
 AliEMCALDigitizer.cxx:326
 AliEMCALDigitizer.cxx:327
 AliEMCALDigitizer.cxx:328
 AliEMCALDigitizer.cxx:329
 AliEMCALDigitizer.cxx:330
 AliEMCALDigitizer.cxx:331
 AliEMCALDigitizer.cxx:332
 AliEMCALDigitizer.cxx:333
 AliEMCALDigitizer.cxx:334
 AliEMCALDigitizer.cxx:335
 AliEMCALDigitizer.cxx:336
 AliEMCALDigitizer.cxx:337
 AliEMCALDigitizer.cxx:338
 AliEMCALDigitizer.cxx:339
 AliEMCALDigitizer.cxx:340
 AliEMCALDigitizer.cxx:341
 AliEMCALDigitizer.cxx:342
 AliEMCALDigitizer.cxx:343
 AliEMCALDigitizer.cxx:344
 AliEMCALDigitizer.cxx:345
 AliEMCALDigitizer.cxx:346
 AliEMCALDigitizer.cxx:347
 AliEMCALDigitizer.cxx:348
 AliEMCALDigitizer.cxx:349
 AliEMCALDigitizer.cxx:350
 AliEMCALDigitizer.cxx:351
 AliEMCALDigitizer.cxx:352
 AliEMCALDigitizer.cxx:353
 AliEMCALDigitizer.cxx:354
 AliEMCALDigitizer.cxx:355
 AliEMCALDigitizer.cxx:356
 AliEMCALDigitizer.cxx:357
 AliEMCALDigitizer.cxx:358
 AliEMCALDigitizer.cxx:359
 AliEMCALDigitizer.cxx:360
 AliEMCALDigitizer.cxx:361
 AliEMCALDigitizer.cxx:362
 AliEMCALDigitizer.cxx:363
 AliEMCALDigitizer.cxx:364
 AliEMCALDigitizer.cxx:365
 AliEMCALDigitizer.cxx:366
 AliEMCALDigitizer.cxx:367
 AliEMCALDigitizer.cxx:368
 AliEMCALDigitizer.cxx:369
 AliEMCALDigitizer.cxx:370
 AliEMCALDigitizer.cxx:371
 AliEMCALDigitizer.cxx:372
 AliEMCALDigitizer.cxx:373
 AliEMCALDigitizer.cxx:374
 AliEMCALDigitizer.cxx:375
 AliEMCALDigitizer.cxx:376
 AliEMCALDigitizer.cxx:377
 AliEMCALDigitizer.cxx:378
 AliEMCALDigitizer.cxx:379
 AliEMCALDigitizer.cxx:380
 AliEMCALDigitizer.cxx:381
 AliEMCALDigitizer.cxx:382
 AliEMCALDigitizer.cxx:383
 AliEMCALDigitizer.cxx:384
 AliEMCALDigitizer.cxx:385
 AliEMCALDigitizer.cxx:386
 AliEMCALDigitizer.cxx:387
 AliEMCALDigitizer.cxx:388
 AliEMCALDigitizer.cxx:389
 AliEMCALDigitizer.cxx:390
 AliEMCALDigitizer.cxx:391
 AliEMCALDigitizer.cxx:392
 AliEMCALDigitizer.cxx:393
 AliEMCALDigitizer.cxx:394
 AliEMCALDigitizer.cxx:395
 AliEMCALDigitizer.cxx:396
 AliEMCALDigitizer.cxx:397
 AliEMCALDigitizer.cxx:398
 AliEMCALDigitizer.cxx:399
 AliEMCALDigitizer.cxx:400
 AliEMCALDigitizer.cxx:401
 AliEMCALDigitizer.cxx:402
 AliEMCALDigitizer.cxx:403
 AliEMCALDigitizer.cxx:404
 AliEMCALDigitizer.cxx:405
 AliEMCALDigitizer.cxx:406
 AliEMCALDigitizer.cxx:407
 AliEMCALDigitizer.cxx:408
 AliEMCALDigitizer.cxx:409
 AliEMCALDigitizer.cxx:410
 AliEMCALDigitizer.cxx:411
 AliEMCALDigitizer.cxx:412
 AliEMCALDigitizer.cxx:413
 AliEMCALDigitizer.cxx:414
 AliEMCALDigitizer.cxx:415
 AliEMCALDigitizer.cxx:416
 AliEMCALDigitizer.cxx:417
 AliEMCALDigitizer.cxx:418
 AliEMCALDigitizer.cxx:419
 AliEMCALDigitizer.cxx:420
 AliEMCALDigitizer.cxx:421
 AliEMCALDigitizer.cxx:422
 AliEMCALDigitizer.cxx:423
 AliEMCALDigitizer.cxx:424
 AliEMCALDigitizer.cxx:425
 AliEMCALDigitizer.cxx:426
 AliEMCALDigitizer.cxx:427
 AliEMCALDigitizer.cxx:428
 AliEMCALDigitizer.cxx:429
 AliEMCALDigitizer.cxx:430
 AliEMCALDigitizer.cxx:431
 AliEMCALDigitizer.cxx:432
 AliEMCALDigitizer.cxx:433
 AliEMCALDigitizer.cxx:434
 AliEMCALDigitizer.cxx:435
 AliEMCALDigitizer.cxx:436
 AliEMCALDigitizer.cxx:437
 AliEMCALDigitizer.cxx:438
 AliEMCALDigitizer.cxx:439
 AliEMCALDigitizer.cxx:440
 AliEMCALDigitizer.cxx:441
 AliEMCALDigitizer.cxx:442
 AliEMCALDigitizer.cxx:443
 AliEMCALDigitizer.cxx:444
 AliEMCALDigitizer.cxx:445
 AliEMCALDigitizer.cxx:446
 AliEMCALDigitizer.cxx:447
 AliEMCALDigitizer.cxx:448
 AliEMCALDigitizer.cxx:449
 AliEMCALDigitizer.cxx:450
 AliEMCALDigitizer.cxx:451
 AliEMCALDigitizer.cxx:452
 AliEMCALDigitizer.cxx:453
 AliEMCALDigitizer.cxx:454
 AliEMCALDigitizer.cxx:455
 AliEMCALDigitizer.cxx:456
 AliEMCALDigitizer.cxx:457
 AliEMCALDigitizer.cxx:458
 AliEMCALDigitizer.cxx:459
 AliEMCALDigitizer.cxx:460
 AliEMCALDigitizer.cxx:461
 AliEMCALDigitizer.cxx:462
 AliEMCALDigitizer.cxx:463
 AliEMCALDigitizer.cxx:464
 AliEMCALDigitizer.cxx:465
 AliEMCALDigitizer.cxx:466
 AliEMCALDigitizer.cxx:467
 AliEMCALDigitizer.cxx:468
 AliEMCALDigitizer.cxx:469
 AliEMCALDigitizer.cxx:470
 AliEMCALDigitizer.cxx:471
 AliEMCALDigitizer.cxx:472
 AliEMCALDigitizer.cxx:473
 AliEMCALDigitizer.cxx:474
 AliEMCALDigitizer.cxx:475
 AliEMCALDigitizer.cxx:476
 AliEMCALDigitizer.cxx:477
 AliEMCALDigitizer.cxx:478
 AliEMCALDigitizer.cxx:479
 AliEMCALDigitizer.cxx:480
 AliEMCALDigitizer.cxx:481
 AliEMCALDigitizer.cxx:482
 AliEMCALDigitizer.cxx:483
 AliEMCALDigitizer.cxx:484
 AliEMCALDigitizer.cxx:485
 AliEMCALDigitizer.cxx:486
 AliEMCALDigitizer.cxx:487
 AliEMCALDigitizer.cxx:488
 AliEMCALDigitizer.cxx:489
 AliEMCALDigitizer.cxx:490
 AliEMCALDigitizer.cxx:491
 AliEMCALDigitizer.cxx:492
 AliEMCALDigitizer.cxx:493
 AliEMCALDigitizer.cxx:494
 AliEMCALDigitizer.cxx:495
 AliEMCALDigitizer.cxx:496
 AliEMCALDigitizer.cxx:497
 AliEMCALDigitizer.cxx:498
 AliEMCALDigitizer.cxx:499
 AliEMCALDigitizer.cxx:500
 AliEMCALDigitizer.cxx:501
 AliEMCALDigitizer.cxx:502
 AliEMCALDigitizer.cxx:503
 AliEMCALDigitizer.cxx:504
 AliEMCALDigitizer.cxx:505
 AliEMCALDigitizer.cxx:506
 AliEMCALDigitizer.cxx:507
 AliEMCALDigitizer.cxx:508
 AliEMCALDigitizer.cxx:509
 AliEMCALDigitizer.cxx:510
 AliEMCALDigitizer.cxx:511
 AliEMCALDigitizer.cxx:512
 AliEMCALDigitizer.cxx:513
 AliEMCALDigitizer.cxx:514
 AliEMCALDigitizer.cxx:515
 AliEMCALDigitizer.cxx:516
 AliEMCALDigitizer.cxx:517
 AliEMCALDigitizer.cxx:518
 AliEMCALDigitizer.cxx:519
 AliEMCALDigitizer.cxx:520
 AliEMCALDigitizer.cxx:521
 AliEMCALDigitizer.cxx:522
 AliEMCALDigitizer.cxx:523
 AliEMCALDigitizer.cxx:524
 AliEMCALDigitizer.cxx:525
 AliEMCALDigitizer.cxx:526
 AliEMCALDigitizer.cxx:527
 AliEMCALDigitizer.cxx:528
 AliEMCALDigitizer.cxx:529
 AliEMCALDigitizer.cxx:530
 AliEMCALDigitizer.cxx:531
 AliEMCALDigitizer.cxx:532
 AliEMCALDigitizer.cxx:533
 AliEMCALDigitizer.cxx:534
 AliEMCALDigitizer.cxx:535
 AliEMCALDigitizer.cxx:536
 AliEMCALDigitizer.cxx:537
 AliEMCALDigitizer.cxx:538
 AliEMCALDigitizer.cxx:539
 AliEMCALDigitizer.cxx:540
 AliEMCALDigitizer.cxx:541
 AliEMCALDigitizer.cxx:542
 AliEMCALDigitizer.cxx:543
 AliEMCALDigitizer.cxx:544
 AliEMCALDigitizer.cxx:545
 AliEMCALDigitizer.cxx:546
 AliEMCALDigitizer.cxx:547
 AliEMCALDigitizer.cxx:548
 AliEMCALDigitizer.cxx:549
 AliEMCALDigitizer.cxx:550
 AliEMCALDigitizer.cxx:551
 AliEMCALDigitizer.cxx:552
 AliEMCALDigitizer.cxx:553
 AliEMCALDigitizer.cxx:554
 AliEMCALDigitizer.cxx:555
 AliEMCALDigitizer.cxx:556
 AliEMCALDigitizer.cxx:557
 AliEMCALDigitizer.cxx:558
 AliEMCALDigitizer.cxx:559
 AliEMCALDigitizer.cxx:560
 AliEMCALDigitizer.cxx:561
 AliEMCALDigitizer.cxx:562
 AliEMCALDigitizer.cxx:563
 AliEMCALDigitizer.cxx:564
 AliEMCALDigitizer.cxx:565
 AliEMCALDigitizer.cxx:566
 AliEMCALDigitizer.cxx:567
 AliEMCALDigitizer.cxx:568
 AliEMCALDigitizer.cxx:569
 AliEMCALDigitizer.cxx:570
 AliEMCALDigitizer.cxx:571
 AliEMCALDigitizer.cxx:572
 AliEMCALDigitizer.cxx:573
 AliEMCALDigitizer.cxx:574
 AliEMCALDigitizer.cxx:575
 AliEMCALDigitizer.cxx:576
 AliEMCALDigitizer.cxx:577
 AliEMCALDigitizer.cxx:578
 AliEMCALDigitizer.cxx:579
 AliEMCALDigitizer.cxx:580
 AliEMCALDigitizer.cxx:581
 AliEMCALDigitizer.cxx:582
 AliEMCALDigitizer.cxx:583
 AliEMCALDigitizer.cxx:584
 AliEMCALDigitizer.cxx:585
 AliEMCALDigitizer.cxx:586
 AliEMCALDigitizer.cxx:587
 AliEMCALDigitizer.cxx:588
 AliEMCALDigitizer.cxx:589
 AliEMCALDigitizer.cxx:590
 AliEMCALDigitizer.cxx:591
 AliEMCALDigitizer.cxx:592
 AliEMCALDigitizer.cxx:593
 AliEMCALDigitizer.cxx:594
 AliEMCALDigitizer.cxx:595
 AliEMCALDigitizer.cxx:596
 AliEMCALDigitizer.cxx:597
 AliEMCALDigitizer.cxx:598
 AliEMCALDigitizer.cxx:599
 AliEMCALDigitizer.cxx:600
 AliEMCALDigitizer.cxx:601
 AliEMCALDigitizer.cxx:602
 AliEMCALDigitizer.cxx:603
 AliEMCALDigitizer.cxx:604
 AliEMCALDigitizer.cxx:605
 AliEMCALDigitizer.cxx:606
 AliEMCALDigitizer.cxx:607
 AliEMCALDigitizer.cxx:608
 AliEMCALDigitizer.cxx:609
 AliEMCALDigitizer.cxx:610
 AliEMCALDigitizer.cxx:611
 AliEMCALDigitizer.cxx:612
 AliEMCALDigitizer.cxx:613
 AliEMCALDigitizer.cxx:614
 AliEMCALDigitizer.cxx:615
 AliEMCALDigitizer.cxx:616
 AliEMCALDigitizer.cxx:617
 AliEMCALDigitizer.cxx:618
 AliEMCALDigitizer.cxx:619
 AliEMCALDigitizer.cxx:620
 AliEMCALDigitizer.cxx:621
 AliEMCALDigitizer.cxx:622
 AliEMCALDigitizer.cxx:623
 AliEMCALDigitizer.cxx:624
 AliEMCALDigitizer.cxx:625
 AliEMCALDigitizer.cxx:626
 AliEMCALDigitizer.cxx:627
 AliEMCALDigitizer.cxx:628
 AliEMCALDigitizer.cxx:629
 AliEMCALDigitizer.cxx:630
 AliEMCALDigitizer.cxx:631
 AliEMCALDigitizer.cxx:632
 AliEMCALDigitizer.cxx:633
 AliEMCALDigitizer.cxx:634
 AliEMCALDigitizer.cxx:635
 AliEMCALDigitizer.cxx:636
 AliEMCALDigitizer.cxx:637
 AliEMCALDigitizer.cxx:638
 AliEMCALDigitizer.cxx:639
 AliEMCALDigitizer.cxx:640
 AliEMCALDigitizer.cxx:641
 AliEMCALDigitizer.cxx:642
 AliEMCALDigitizer.cxx:643
 AliEMCALDigitizer.cxx:644
 AliEMCALDigitizer.cxx:645
 AliEMCALDigitizer.cxx:646
 AliEMCALDigitizer.cxx:647
 AliEMCALDigitizer.cxx:648
 AliEMCALDigitizer.cxx:649
 AliEMCALDigitizer.cxx:650
 AliEMCALDigitizer.cxx:651
 AliEMCALDigitizer.cxx:652
 AliEMCALDigitizer.cxx:653
 AliEMCALDigitizer.cxx:654
 AliEMCALDigitizer.cxx:655
 AliEMCALDigitizer.cxx:656
 AliEMCALDigitizer.cxx:657
 AliEMCALDigitizer.cxx:658
 AliEMCALDigitizer.cxx:659
 AliEMCALDigitizer.cxx:660
 AliEMCALDigitizer.cxx:661
 AliEMCALDigitizer.cxx:662
 AliEMCALDigitizer.cxx:663
 AliEMCALDigitizer.cxx:664
 AliEMCALDigitizer.cxx:665
 AliEMCALDigitizer.cxx:666
 AliEMCALDigitizer.cxx:667
 AliEMCALDigitizer.cxx:668
 AliEMCALDigitizer.cxx:669
 AliEMCALDigitizer.cxx:670
 AliEMCALDigitizer.cxx:671
 AliEMCALDigitizer.cxx:672
 AliEMCALDigitizer.cxx:673
 AliEMCALDigitizer.cxx:674
 AliEMCALDigitizer.cxx:675
 AliEMCALDigitizer.cxx:676
 AliEMCALDigitizer.cxx:677
 AliEMCALDigitizer.cxx:678
 AliEMCALDigitizer.cxx:679
 AliEMCALDigitizer.cxx:680
 AliEMCALDigitizer.cxx:681
 AliEMCALDigitizer.cxx:682
 AliEMCALDigitizer.cxx:683
 AliEMCALDigitizer.cxx:684
 AliEMCALDigitizer.cxx:685
 AliEMCALDigitizer.cxx:686
 AliEMCALDigitizer.cxx:687
 AliEMCALDigitizer.cxx:688
 AliEMCALDigitizer.cxx:689
 AliEMCALDigitizer.cxx:690
 AliEMCALDigitizer.cxx:691
 AliEMCALDigitizer.cxx:692
 AliEMCALDigitizer.cxx:693
 AliEMCALDigitizer.cxx:694
 AliEMCALDigitizer.cxx:695
 AliEMCALDigitizer.cxx:696
 AliEMCALDigitizer.cxx:697
 AliEMCALDigitizer.cxx:698
 AliEMCALDigitizer.cxx:699
 AliEMCALDigitizer.cxx:700
 AliEMCALDigitizer.cxx:701
 AliEMCALDigitizer.cxx:702
 AliEMCALDigitizer.cxx:703
 AliEMCALDigitizer.cxx:704
 AliEMCALDigitizer.cxx:705
 AliEMCALDigitizer.cxx:706
 AliEMCALDigitizer.cxx:707
 AliEMCALDigitizer.cxx:708
 AliEMCALDigitizer.cxx:709
 AliEMCALDigitizer.cxx:710
 AliEMCALDigitizer.cxx:711
 AliEMCALDigitizer.cxx:712
 AliEMCALDigitizer.cxx:713
 AliEMCALDigitizer.cxx:714
 AliEMCALDigitizer.cxx:715
 AliEMCALDigitizer.cxx:716
 AliEMCALDigitizer.cxx:717
 AliEMCALDigitizer.cxx:718
 AliEMCALDigitizer.cxx:719
 AliEMCALDigitizer.cxx:720
 AliEMCALDigitizer.cxx:721
 AliEMCALDigitizer.cxx:722
 AliEMCALDigitizer.cxx:723
 AliEMCALDigitizer.cxx:724
 AliEMCALDigitizer.cxx:725
 AliEMCALDigitizer.cxx:726
 AliEMCALDigitizer.cxx:727
 AliEMCALDigitizer.cxx:728
 AliEMCALDigitizer.cxx:729
 AliEMCALDigitizer.cxx:730
 AliEMCALDigitizer.cxx:731
 AliEMCALDigitizer.cxx:732
 AliEMCALDigitizer.cxx:733
 AliEMCALDigitizer.cxx:734
 AliEMCALDigitizer.cxx:735
 AliEMCALDigitizer.cxx:736
 AliEMCALDigitizer.cxx:737
 AliEMCALDigitizer.cxx:738
 AliEMCALDigitizer.cxx:739
 AliEMCALDigitizer.cxx:740
 AliEMCALDigitizer.cxx:741
 AliEMCALDigitizer.cxx:742
 AliEMCALDigitizer.cxx:743
 AliEMCALDigitizer.cxx:744
 AliEMCALDigitizer.cxx:745
 AliEMCALDigitizer.cxx:746
 AliEMCALDigitizer.cxx:747
 AliEMCALDigitizer.cxx:748
 AliEMCALDigitizer.cxx:749
 AliEMCALDigitizer.cxx:750
 AliEMCALDigitizer.cxx:751
 AliEMCALDigitizer.cxx:752
 AliEMCALDigitizer.cxx:753
 AliEMCALDigitizer.cxx:754
 AliEMCALDigitizer.cxx:755
 AliEMCALDigitizer.cxx:756
 AliEMCALDigitizer.cxx:757
 AliEMCALDigitizer.cxx:758
 AliEMCALDigitizer.cxx:759
 AliEMCALDigitizer.cxx:760
 AliEMCALDigitizer.cxx:761
 AliEMCALDigitizer.cxx:762
 AliEMCALDigitizer.cxx:763
 AliEMCALDigitizer.cxx:764
 AliEMCALDigitizer.cxx:765
 AliEMCALDigitizer.cxx:766
 AliEMCALDigitizer.cxx:767
 AliEMCALDigitizer.cxx:768
 AliEMCALDigitizer.cxx:769
 AliEMCALDigitizer.cxx:770
 AliEMCALDigitizer.cxx:771
 AliEMCALDigitizer.cxx:772
 AliEMCALDigitizer.cxx:773
 AliEMCALDigitizer.cxx:774
 AliEMCALDigitizer.cxx:775
 AliEMCALDigitizer.cxx:776
 AliEMCALDigitizer.cxx:777
 AliEMCALDigitizer.cxx:778
 AliEMCALDigitizer.cxx:779
 AliEMCALDigitizer.cxx:780
 AliEMCALDigitizer.cxx:781
 AliEMCALDigitizer.cxx:782
 AliEMCALDigitizer.cxx:783
 AliEMCALDigitizer.cxx:784
 AliEMCALDigitizer.cxx:785
 AliEMCALDigitizer.cxx:786
 AliEMCALDigitizer.cxx:787
 AliEMCALDigitizer.cxx:788
 AliEMCALDigitizer.cxx:789
 AliEMCALDigitizer.cxx:790
 AliEMCALDigitizer.cxx:791
 AliEMCALDigitizer.cxx:792
 AliEMCALDigitizer.cxx:793
 AliEMCALDigitizer.cxx:794
 AliEMCALDigitizer.cxx:795
 AliEMCALDigitizer.cxx:796
 AliEMCALDigitizer.cxx:797
 AliEMCALDigitizer.cxx:798
 AliEMCALDigitizer.cxx:799
 AliEMCALDigitizer.cxx:800
 AliEMCALDigitizer.cxx:801
 AliEMCALDigitizer.cxx:802
 AliEMCALDigitizer.cxx:803
 AliEMCALDigitizer.cxx:804
 AliEMCALDigitizer.cxx:805
 AliEMCALDigitizer.cxx:806
 AliEMCALDigitizer.cxx:807
 AliEMCALDigitizer.cxx:808
 AliEMCALDigitizer.cxx:809
 AliEMCALDigitizer.cxx:810
 AliEMCALDigitizer.cxx:811
 AliEMCALDigitizer.cxx:812
 AliEMCALDigitizer.cxx:813
 AliEMCALDigitizer.cxx:814
 AliEMCALDigitizer.cxx:815
 AliEMCALDigitizer.cxx:816
 AliEMCALDigitizer.cxx:817
 AliEMCALDigitizer.cxx:818
 AliEMCALDigitizer.cxx:819
 AliEMCALDigitizer.cxx:820
 AliEMCALDigitizer.cxx:821
 AliEMCALDigitizer.cxx:822
 AliEMCALDigitizer.cxx:823
 AliEMCALDigitizer.cxx:824
 AliEMCALDigitizer.cxx:825
 AliEMCALDigitizer.cxx:826
 AliEMCALDigitizer.cxx:827
 AliEMCALDigitizer.cxx:828
 AliEMCALDigitizer.cxx:829
 AliEMCALDigitizer.cxx:830
 AliEMCALDigitizer.cxx:831
 AliEMCALDigitizer.cxx:832
 AliEMCALDigitizer.cxx:833
 AliEMCALDigitizer.cxx:834
 AliEMCALDigitizer.cxx:835
 AliEMCALDigitizer.cxx:836
 AliEMCALDigitizer.cxx:837
 AliEMCALDigitizer.cxx:838
 AliEMCALDigitizer.cxx:839
 AliEMCALDigitizer.cxx:840
 AliEMCALDigitizer.cxx:841
 AliEMCALDigitizer.cxx:842
 AliEMCALDigitizer.cxx:843
 AliEMCALDigitizer.cxx:844
 AliEMCALDigitizer.cxx:845
 AliEMCALDigitizer.cxx:846
 AliEMCALDigitizer.cxx:847
 AliEMCALDigitizer.cxx:848
 AliEMCALDigitizer.cxx:849
 AliEMCALDigitizer.cxx:850
 AliEMCALDigitizer.cxx:851
 AliEMCALDigitizer.cxx:852
 AliEMCALDigitizer.cxx:853
 AliEMCALDigitizer.cxx:854
 AliEMCALDigitizer.cxx:855
 AliEMCALDigitizer.cxx:856
 AliEMCALDigitizer.cxx:857
 AliEMCALDigitizer.cxx:858
 AliEMCALDigitizer.cxx:859
 AliEMCALDigitizer.cxx:860
 AliEMCALDigitizer.cxx:861
 AliEMCALDigitizer.cxx:862
 AliEMCALDigitizer.cxx:863
 AliEMCALDigitizer.cxx:864
 AliEMCALDigitizer.cxx:865
 AliEMCALDigitizer.cxx:866
 AliEMCALDigitizer.cxx:867
 AliEMCALDigitizer.cxx:868
 AliEMCALDigitizer.cxx:869
 AliEMCALDigitizer.cxx:870
 AliEMCALDigitizer.cxx:871
 AliEMCALDigitizer.cxx:872
 AliEMCALDigitizer.cxx:873
 AliEMCALDigitizer.cxx:874
 AliEMCALDigitizer.cxx:875
 AliEMCALDigitizer.cxx:876
 AliEMCALDigitizer.cxx:877
 AliEMCALDigitizer.cxx:878
 AliEMCALDigitizer.cxx:879
 AliEMCALDigitizer.cxx:880
 AliEMCALDigitizer.cxx:881
 AliEMCALDigitizer.cxx:882
 AliEMCALDigitizer.cxx:883
 AliEMCALDigitizer.cxx:884
 AliEMCALDigitizer.cxx:885
 AliEMCALDigitizer.cxx:886
 AliEMCALDigitizer.cxx:887
 AliEMCALDigitizer.cxx:888
 AliEMCALDigitizer.cxx:889
 AliEMCALDigitizer.cxx:890
 AliEMCALDigitizer.cxx:891
 AliEMCALDigitizer.cxx:892
 AliEMCALDigitizer.cxx:893
 AliEMCALDigitizer.cxx:894
 AliEMCALDigitizer.cxx:895
 AliEMCALDigitizer.cxx:896
 AliEMCALDigitizer.cxx:897
 AliEMCALDigitizer.cxx:898
 AliEMCALDigitizer.cxx:899
 AliEMCALDigitizer.cxx:900
 AliEMCALDigitizer.cxx:901
 AliEMCALDigitizer.cxx:902
 AliEMCALDigitizer.cxx:903
 AliEMCALDigitizer.cxx:904
 AliEMCALDigitizer.cxx:905
 AliEMCALDigitizer.cxx:906
 AliEMCALDigitizer.cxx:907
 AliEMCALDigitizer.cxx:908
 AliEMCALDigitizer.cxx:909
 AliEMCALDigitizer.cxx:910
 AliEMCALDigitizer.cxx:911
 AliEMCALDigitizer.cxx:912
 AliEMCALDigitizer.cxx:913
 AliEMCALDigitizer.cxx:914
 AliEMCALDigitizer.cxx:915
 AliEMCALDigitizer.cxx:916
 AliEMCALDigitizer.cxx:917
 AliEMCALDigitizer.cxx:918
 AliEMCALDigitizer.cxx:919
 AliEMCALDigitizer.cxx:920
 AliEMCALDigitizer.cxx:921
 AliEMCALDigitizer.cxx:922
 AliEMCALDigitizer.cxx:923
 AliEMCALDigitizer.cxx:924
 AliEMCALDigitizer.cxx:925
 AliEMCALDigitizer.cxx:926
 AliEMCALDigitizer.cxx:927
 AliEMCALDigitizer.cxx:928
 AliEMCALDigitizer.cxx:929
 AliEMCALDigitizer.cxx:930
 AliEMCALDigitizer.cxx:931
 AliEMCALDigitizer.cxx:932
 AliEMCALDigitizer.cxx:933
 AliEMCALDigitizer.cxx:934
 AliEMCALDigitizer.cxx:935
 AliEMCALDigitizer.cxx:936
 AliEMCALDigitizer.cxx:937
 AliEMCALDigitizer.cxx:938
 AliEMCALDigitizer.cxx:939
 AliEMCALDigitizer.cxx:940
 AliEMCALDigitizer.cxx:941
 AliEMCALDigitizer.cxx:942
 AliEMCALDigitizer.cxx:943
 AliEMCALDigitizer.cxx:944
 AliEMCALDigitizer.cxx:945
 AliEMCALDigitizer.cxx:946
 AliEMCALDigitizer.cxx:947
 AliEMCALDigitizer.cxx:948
 AliEMCALDigitizer.cxx:949
 AliEMCALDigitizer.cxx:950
 AliEMCALDigitizer.cxx:951
 AliEMCALDigitizer.cxx:952
 AliEMCALDigitizer.cxx:953
 AliEMCALDigitizer.cxx:954
 AliEMCALDigitizer.cxx:955
 AliEMCALDigitizer.cxx:956
 AliEMCALDigitizer.cxx:957
 AliEMCALDigitizer.cxx:958
 AliEMCALDigitizer.cxx:959
 AliEMCALDigitizer.cxx:960
 AliEMCALDigitizer.cxx:961
 AliEMCALDigitizer.cxx:962
 AliEMCALDigitizer.cxx:963
 AliEMCALDigitizer.cxx:964
 AliEMCALDigitizer.cxx:965
 AliEMCALDigitizer.cxx:966
 AliEMCALDigitizer.cxx:967
 AliEMCALDigitizer.cxx:968
 AliEMCALDigitizer.cxx:969
 AliEMCALDigitizer.cxx:970
 AliEMCALDigitizer.cxx:971
 AliEMCALDigitizer.cxx:972
 AliEMCALDigitizer.cxx:973
 AliEMCALDigitizer.cxx:974
 AliEMCALDigitizer.cxx:975
 AliEMCALDigitizer.cxx:976
 AliEMCALDigitizer.cxx:977
 AliEMCALDigitizer.cxx:978
 AliEMCALDigitizer.cxx:979
 AliEMCALDigitizer.cxx:980
 AliEMCALDigitizer.cxx:981
 AliEMCALDigitizer.cxx:982
 AliEMCALDigitizer.cxx:983
 AliEMCALDigitizer.cxx:984
 AliEMCALDigitizer.cxx:985
 AliEMCALDigitizer.cxx:986
 AliEMCALDigitizer.cxx:987
 AliEMCALDigitizer.cxx:988
 AliEMCALDigitizer.cxx:989
 AliEMCALDigitizer.cxx:990
 AliEMCALDigitizer.cxx:991
 AliEMCALDigitizer.cxx:992
 AliEMCALDigitizer.cxx:993
 AliEMCALDigitizer.cxx:994
 AliEMCALDigitizer.cxx:995
 AliEMCALDigitizer.cxx:996
 AliEMCALDigitizer.cxx:997
 AliEMCALDigitizer.cxx:998
 AliEMCALDigitizer.cxx:999
 AliEMCALDigitizer.cxx:1000
 AliEMCALDigitizer.cxx:1001
 AliEMCALDigitizer.cxx:1002
 AliEMCALDigitizer.cxx:1003
 AliEMCALDigitizer.cxx:1004
 AliEMCALDigitizer.cxx:1005
 AliEMCALDigitizer.cxx:1006
 AliEMCALDigitizer.cxx:1007
 AliEMCALDigitizer.cxx:1008
 AliEMCALDigitizer.cxx:1009
 AliEMCALDigitizer.cxx:1010
 AliEMCALDigitizer.cxx:1011
 AliEMCALDigitizer.cxx:1012
 AliEMCALDigitizer.cxx:1013
 AliEMCALDigitizer.cxx:1014
 AliEMCALDigitizer.cxx:1015
 AliEMCALDigitizer.cxx:1016
 AliEMCALDigitizer.cxx:1017
 AliEMCALDigitizer.cxx:1018
 AliEMCALDigitizer.cxx:1019
 AliEMCALDigitizer.cxx:1020
 AliEMCALDigitizer.cxx:1021
 AliEMCALDigitizer.cxx:1022
 AliEMCALDigitizer.cxx:1023
 AliEMCALDigitizer.cxx:1024
 AliEMCALDigitizer.cxx:1025
 AliEMCALDigitizer.cxx:1026
 AliEMCALDigitizer.cxx:1027
 AliEMCALDigitizer.cxx:1028
 AliEMCALDigitizer.cxx:1029
 AliEMCALDigitizer.cxx:1030
 AliEMCALDigitizer.cxx:1031
 AliEMCALDigitizer.cxx:1032
 AliEMCALDigitizer.cxx:1033
 AliEMCALDigitizer.cxx:1034
 AliEMCALDigitizer.cxx:1035
 AliEMCALDigitizer.cxx:1036
 AliEMCALDigitizer.cxx:1037
 AliEMCALDigitizer.cxx:1038
 AliEMCALDigitizer.cxx:1039
 AliEMCALDigitizer.cxx:1040
 AliEMCALDigitizer.cxx:1041
 AliEMCALDigitizer.cxx:1042
 AliEMCALDigitizer.cxx:1043
 AliEMCALDigitizer.cxx:1044
 AliEMCALDigitizer.cxx:1045
 AliEMCALDigitizer.cxx:1046
 AliEMCALDigitizer.cxx:1047
 AliEMCALDigitizer.cxx:1048
 AliEMCALDigitizer.cxx:1049
 AliEMCALDigitizer.cxx:1050
 AliEMCALDigitizer.cxx:1051
 AliEMCALDigitizer.cxx:1052
 AliEMCALDigitizer.cxx:1053
 AliEMCALDigitizer.cxx:1054
 AliEMCALDigitizer.cxx:1055
 AliEMCALDigitizer.cxx:1056
 AliEMCALDigitizer.cxx:1057
 AliEMCALDigitizer.cxx:1058
 AliEMCALDigitizer.cxx:1059
 AliEMCALDigitizer.cxx:1060
 AliEMCALDigitizer.cxx:1061
 AliEMCALDigitizer.cxx:1062
 AliEMCALDigitizer.cxx:1063
 AliEMCALDigitizer.cxx:1064
 AliEMCALDigitizer.cxx:1065
 AliEMCALDigitizer.cxx:1066
 AliEMCALDigitizer.cxx:1067
 AliEMCALDigitizer.cxx:1068
 AliEMCALDigitizer.cxx:1069
 AliEMCALDigitizer.cxx:1070
 AliEMCALDigitizer.cxx:1071
 AliEMCALDigitizer.cxx:1072
 AliEMCALDigitizer.cxx:1073
 AliEMCALDigitizer.cxx:1074
 AliEMCALDigitizer.cxx:1075
 AliEMCALDigitizer.cxx:1076
 AliEMCALDigitizer.cxx:1077
 AliEMCALDigitizer.cxx:1078
 AliEMCALDigitizer.cxx:1079
 AliEMCALDigitizer.cxx:1080
 AliEMCALDigitizer.cxx:1081
 AliEMCALDigitizer.cxx:1082
 AliEMCALDigitizer.cxx:1083
 AliEMCALDigitizer.cxx:1084
 AliEMCALDigitizer.cxx:1085
 AliEMCALDigitizer.cxx:1086
 AliEMCALDigitizer.cxx:1087
 AliEMCALDigitizer.cxx:1088
 AliEMCALDigitizer.cxx:1089
 AliEMCALDigitizer.cxx:1090
 AliEMCALDigitizer.cxx:1091
 AliEMCALDigitizer.cxx:1092
 AliEMCALDigitizer.cxx:1093
 AliEMCALDigitizer.cxx:1094
 AliEMCALDigitizer.cxx:1095
 AliEMCALDigitizer.cxx:1096
 AliEMCALDigitizer.cxx:1097
 AliEMCALDigitizer.cxx:1098
 AliEMCALDigitizer.cxx:1099
 AliEMCALDigitizer.cxx:1100
 AliEMCALDigitizer.cxx:1101
 AliEMCALDigitizer.cxx:1102
 AliEMCALDigitizer.cxx:1103
 AliEMCALDigitizer.cxx:1104
 AliEMCALDigitizer.cxx:1105
 AliEMCALDigitizer.cxx:1106
 AliEMCALDigitizer.cxx:1107
 AliEMCALDigitizer.cxx:1108
 AliEMCALDigitizer.cxx:1109
 AliEMCALDigitizer.cxx:1110
 AliEMCALDigitizer.cxx:1111
 AliEMCALDigitizer.cxx:1112
 AliEMCALDigitizer.cxx:1113
 AliEMCALDigitizer.cxx:1114
 AliEMCALDigitizer.cxx:1115
 AliEMCALDigitizer.cxx:1116
 AliEMCALDigitizer.cxx:1117
 AliEMCALDigitizer.cxx:1118
 AliEMCALDigitizer.cxx:1119
 AliEMCALDigitizer.cxx:1120
 AliEMCALDigitizer.cxx:1121
 AliEMCALDigitizer.cxx:1122
 AliEMCALDigitizer.cxx:1123
 AliEMCALDigitizer.cxx:1124
 AliEMCALDigitizer.cxx:1125
 AliEMCALDigitizer.cxx:1126
 AliEMCALDigitizer.cxx:1127
 AliEMCALDigitizer.cxx:1128
 AliEMCALDigitizer.cxx:1129
 AliEMCALDigitizer.cxx:1130
 AliEMCALDigitizer.cxx:1131
 AliEMCALDigitizer.cxx:1132
 AliEMCALDigitizer.cxx:1133
 AliEMCALDigitizer.cxx:1134
 AliEMCALDigitizer.cxx:1135
 AliEMCALDigitizer.cxx:1136
 AliEMCALDigitizer.cxx:1137
 AliEMCALDigitizer.cxx:1138
 AliEMCALDigitizer.cxx:1139
 AliEMCALDigitizer.cxx:1140
 AliEMCALDigitizer.cxx:1141
 AliEMCALDigitizer.cxx:1142
 AliEMCALDigitizer.cxx:1143
 AliEMCALDigitizer.cxx:1144
 AliEMCALDigitizer.cxx:1145
 AliEMCALDigitizer.cxx:1146
 AliEMCALDigitizer.cxx:1147
 AliEMCALDigitizer.cxx:1148
 AliEMCALDigitizer.cxx:1149
 AliEMCALDigitizer.cxx:1150
 AliEMCALDigitizer.cxx:1151
 AliEMCALDigitizer.cxx:1152
 AliEMCALDigitizer.cxx:1153
 AliEMCALDigitizer.cxx:1154
 AliEMCALDigitizer.cxx:1155
 AliEMCALDigitizer.cxx:1156
 AliEMCALDigitizer.cxx:1157
 AliEMCALDigitizer.cxx:1158
 AliEMCALDigitizer.cxx:1159
 AliEMCALDigitizer.cxx:1160
 AliEMCALDigitizer.cxx:1161
 AliEMCALDigitizer.cxx:1162
 AliEMCALDigitizer.cxx:1163
 AliEMCALDigitizer.cxx:1164
 AliEMCALDigitizer.cxx:1165
 AliEMCALDigitizer.cxx:1166
 AliEMCALDigitizer.cxx:1167
 AliEMCALDigitizer.cxx:1168
 AliEMCALDigitizer.cxx:1169
 AliEMCALDigitizer.cxx:1170
 AliEMCALDigitizer.cxx:1171
 AliEMCALDigitizer.cxx:1172
 AliEMCALDigitizer.cxx:1173
 AliEMCALDigitizer.cxx:1174
 AliEMCALDigitizer.cxx:1175
 AliEMCALDigitizer.cxx:1176
 AliEMCALDigitizer.cxx:1177
 AliEMCALDigitizer.cxx:1178
 AliEMCALDigitizer.cxx:1179
 AliEMCALDigitizer.cxx:1180
 AliEMCALDigitizer.cxx:1181
 AliEMCALDigitizer.cxx:1182
 AliEMCALDigitizer.cxx:1183
 AliEMCALDigitizer.cxx:1184
 AliEMCALDigitizer.cxx:1185
 AliEMCALDigitizer.cxx:1186
 AliEMCALDigitizer.cxx:1187
 AliEMCALDigitizer.cxx:1188
 AliEMCALDigitizer.cxx:1189
 AliEMCALDigitizer.cxx:1190
 AliEMCALDigitizer.cxx:1191
 AliEMCALDigitizer.cxx:1192
 AliEMCALDigitizer.cxx:1193
 AliEMCALDigitizer.cxx:1194
 AliEMCALDigitizer.cxx:1195
 AliEMCALDigitizer.cxx:1196
 AliEMCALDigitizer.cxx:1197
 AliEMCALDigitizer.cxx:1198
 AliEMCALDigitizer.cxx:1199
 AliEMCALDigitizer.cxx:1200
 AliEMCALDigitizer.cxx:1201
 AliEMCALDigitizer.cxx:1202
 AliEMCALDigitizer.cxx:1203
 AliEMCALDigitizer.cxx:1204
 AliEMCALDigitizer.cxx:1205
 AliEMCALDigitizer.cxx:1206
 AliEMCALDigitizer.cxx:1207
 AliEMCALDigitizer.cxx:1208
 AliEMCALDigitizer.cxx:1209
 AliEMCALDigitizer.cxx:1210
 AliEMCALDigitizer.cxx:1211
 AliEMCALDigitizer.cxx:1212
 AliEMCALDigitizer.cxx:1213
 AliEMCALDigitizer.cxx:1214
 AliEMCALDigitizer.cxx:1215
 AliEMCALDigitizer.cxx:1216
 AliEMCALDigitizer.cxx:1217
 AliEMCALDigitizer.cxx:1218
 AliEMCALDigitizer.cxx:1219
 AliEMCALDigitizer.cxx:1220
 AliEMCALDigitizer.cxx:1221
 AliEMCALDigitizer.cxx:1222
 AliEMCALDigitizer.cxx:1223
 AliEMCALDigitizer.cxx:1224
 AliEMCALDigitizer.cxx:1225
 AliEMCALDigitizer.cxx:1226
 AliEMCALDigitizer.cxx:1227
 AliEMCALDigitizer.cxx:1228
 AliEMCALDigitizer.cxx:1229
 AliEMCALDigitizer.cxx:1230
 AliEMCALDigitizer.cxx:1231
 AliEMCALDigitizer.cxx:1232
 AliEMCALDigitizer.cxx:1233
 AliEMCALDigitizer.cxx:1234
 AliEMCALDigitizer.cxx:1235
 AliEMCALDigitizer.cxx:1236
 AliEMCALDigitizer.cxx:1237
 AliEMCALDigitizer.cxx:1238
 AliEMCALDigitizer.cxx:1239
 AliEMCALDigitizer.cxx:1240
 AliEMCALDigitizer.cxx:1241
 AliEMCALDigitizer.cxx:1242
 AliEMCALDigitizer.cxx:1243
 AliEMCALDigitizer.cxx:1244
 AliEMCALDigitizer.cxx:1245
 AliEMCALDigitizer.cxx:1246
 AliEMCALDigitizer.cxx:1247
 AliEMCALDigitizer.cxx:1248
 AliEMCALDigitizer.cxx:1249
 AliEMCALDigitizer.cxx:1250
 AliEMCALDigitizer.cxx:1251
 AliEMCALDigitizer.cxx:1252
 AliEMCALDigitizer.cxx:1253
 AliEMCALDigitizer.cxx:1254
 AliEMCALDigitizer.cxx:1255
 AliEMCALDigitizer.cxx:1256
 AliEMCALDigitizer.cxx:1257
 AliEMCALDigitizer.cxx:1258
 AliEMCALDigitizer.cxx:1259
 AliEMCALDigitizer.cxx:1260
 AliEMCALDigitizer.cxx:1261
 AliEMCALDigitizer.cxx:1262
 AliEMCALDigitizer.cxx:1263
 AliEMCALDigitizer.cxx:1264
 AliEMCALDigitizer.cxx:1265
 AliEMCALDigitizer.cxx:1266
 AliEMCALDigitizer.cxx:1267
 AliEMCALDigitizer.cxx:1268
 AliEMCALDigitizer.cxx:1269
 AliEMCALDigitizer.cxx:1270
 AliEMCALDigitizer.cxx:1271
 AliEMCALDigitizer.cxx:1272
 AliEMCALDigitizer.cxx:1273
 AliEMCALDigitizer.cxx:1274
 AliEMCALDigitizer.cxx:1275
 AliEMCALDigitizer.cxx:1276
 AliEMCALDigitizer.cxx:1277
 AliEMCALDigitizer.cxx:1278
 AliEMCALDigitizer.cxx:1279
 AliEMCALDigitizer.cxx:1280
 AliEMCALDigitizer.cxx:1281
 AliEMCALDigitizer.cxx:1282
 AliEMCALDigitizer.cxx:1283
 AliEMCALDigitizer.cxx:1284
 AliEMCALDigitizer.cxx:1285
 AliEMCALDigitizer.cxx:1286
 AliEMCALDigitizer.cxx:1287
 AliEMCALDigitizer.cxx:1288
 AliEMCALDigitizer.cxx:1289
 AliEMCALDigitizer.cxx:1290
 AliEMCALDigitizer.cxx:1291
 AliEMCALDigitizer.cxx:1292
 AliEMCALDigitizer.cxx:1293
 AliEMCALDigitizer.cxx:1294
 AliEMCALDigitizer.cxx:1295
 AliEMCALDigitizer.cxx:1296
 AliEMCALDigitizer.cxx:1297
 AliEMCALDigitizer.cxx:1298
 AliEMCALDigitizer.cxx:1299
 AliEMCALDigitizer.cxx:1300
 AliEMCALDigitizer.cxx:1301
 AliEMCALDigitizer.cxx:1302
 AliEMCALDigitizer.cxx:1303
 AliEMCALDigitizer.cxx:1304
 AliEMCALDigitizer.cxx:1305
 AliEMCALDigitizer.cxx:1306
 AliEMCALDigitizer.cxx:1307
 AliEMCALDigitizer.cxx:1308
 AliEMCALDigitizer.cxx:1309
 AliEMCALDigitizer.cxx:1310
 AliEMCALDigitizer.cxx:1311
 AliEMCALDigitizer.cxx:1312
 AliEMCALDigitizer.cxx:1313
 AliEMCALDigitizer.cxx:1314
 AliEMCALDigitizer.cxx:1315
 AliEMCALDigitizer.cxx:1316
 AliEMCALDigitizer.cxx:1317
 AliEMCALDigitizer.cxx:1318
 AliEMCALDigitizer.cxx:1319
 AliEMCALDigitizer.cxx:1320
 AliEMCALDigitizer.cxx:1321
 AliEMCALDigitizer.cxx:1322
 AliEMCALDigitizer.cxx:1323
 AliEMCALDigitizer.cxx:1324
 AliEMCALDigitizer.cxx:1325
 AliEMCALDigitizer.cxx:1326
 AliEMCALDigitizer.cxx:1327
 AliEMCALDigitizer.cxx:1328
 AliEMCALDigitizer.cxx:1329
 AliEMCALDigitizer.cxx:1330
 AliEMCALDigitizer.cxx:1331
 AliEMCALDigitizer.cxx:1332
 AliEMCALDigitizer.cxx:1333
 AliEMCALDigitizer.cxx:1334
 AliEMCALDigitizer.cxx:1335
 AliEMCALDigitizer.cxx:1336
 AliEMCALDigitizer.cxx:1337
 AliEMCALDigitizer.cxx:1338
 AliEMCALDigitizer.cxx:1339
 AliEMCALDigitizer.cxx:1340
 AliEMCALDigitizer.cxx:1341
 AliEMCALDigitizer.cxx:1342
 AliEMCALDigitizer.cxx:1343
 AliEMCALDigitizer.cxx:1344
 AliEMCALDigitizer.cxx:1345
 AliEMCALDigitizer.cxx:1346
 AliEMCALDigitizer.cxx:1347
 AliEMCALDigitizer.cxx:1348
 AliEMCALDigitizer.cxx:1349
 AliEMCALDigitizer.cxx:1350