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: AliEMCALRecoUtils.cxx | Sun Dec 8 06:56:48 2013 +0100 | Constantin Loizides  $ */

///////////////////////////////////////////////////////////////////////////////
//
// Class AliEMCALRecoUtils
// Some utilities to recalculate the cluster position or energy linearity
//
//
// Author:  Gustavo Conesa (LPSC- Grenoble) 
//          Track matching part: Rongrong Ma (Yale)

///////////////////////////////////////////////////////////////////////////////
// --- standard c ---

// standard C++ includes
//#include <Riostream.h>

// ROOT includes
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TGeoBBox.h>
#include <TH2F.h>
#include <TArrayI.h>
#include <TArrayF.h>
#include <TObjArray.h>

// STEER includes
#include "AliVCluster.h"
#include "AliVCaloCells.h"
#include "AliLog.h"
#include "AliPID.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliESDtrack.h"
#include "AliAODTrack.h"
#include "AliExternalTrackParam.h"
#include "AliESDfriendTrack.h"
#include "AliTrackerBase.h"

// EMCAL includes
#include "AliEMCALRecoUtils.h"
#include "AliEMCALGeometry.h"
#include "AliTrackerBase.h"
#include "AliEMCALPIDUtils.h"

ClassImp(AliEMCALRecoUtils)
  
//_____________________________________
AliEMCALRecoUtils::AliEMCALRecoUtils():
  fParticleType(0),                       fPosAlgo(0),                            fW0(0), 
  fNonLinearityFunction(0),               fNonLinearThreshold(0),
  fSmearClusterEnergy(kFALSE),            fRandom(),
  fCellsRecalibrated(kFALSE),             fRecalibration(kFALSE),                 fEMCALRecalibrationFactors(),
  fTimeRecalibration(kFALSE),             fEMCALTimeRecalibrationFactors(),       fUseRunCorrectionFactors(kFALSE),       
  fRemoveBadChannels(kFALSE),             fRecalDistToBadChannels(kFALSE),        fEMCALBadChannelMap(),
  fNCellsFromEMCALBorder(0),              fNoEMCALBorderAtEta0(kTRUE),
  fRejectExoticCluster(kFALSE),           fRejectExoticCells(kFALSE), 
  fExoticCellFraction(0),                 fExoticCellDiffTime(0),                 fExoticCellMinAmplitude(0),
  fPIDUtils(),                            fAODFilterMask(0),
  fAODHybridTracks(0),                    fAODTPCOnlyTracks(0),
  fMatchedTrackIndex(0x0),                fMatchedClusterIndex(0x0), 
  fResidualEta(0x0), fResidualPhi(0x0),   fCutEtaPhiSum(kFALSE),                  fCutEtaPhiSeparate(kFALSE), 
  fCutR(0),                               fCutEta(0),                             fCutPhi(0),
  fClusterWindow(0),                      fMass(0),                           
  fStepSurface(0),                        fStepCluster(0),
  fITSTrackSA(kFALSE),                    fEMCalSurfaceDistance(440.),
  fTrackCutsType(0),                      fCutMinTrackPt(0),                      fCutMinNClusterTPC(0), 
  fCutMinNClusterITS(0),                  fCutMaxChi2PerClusterTPC(0),            fCutMaxChi2PerClusterITS(0),
  fCutRequireTPCRefit(kFALSE),            fCutRequireITSRefit(kFALSE),            fCutAcceptKinkDaughters(kFALSE),
  fCutMaxDCAToVertexXY(0),                fCutMaxDCAToVertexZ(0),                 fCutDCAToVertex2D(kFALSE),
  fCutRequireITSStandAlone(kFALSE),       fCutRequireITSpureSA(kFALSE)
{
//
  // Constructor.
  // Initialize all constant values which have to be used
  // during Reco algorithm execution
  //
  
  // Init parameters
  InitParameters();
  
  //Track matching
  fMatchedTrackIndex     = new TArrayI();
  fMatchedClusterIndex   = new TArrayI();
  fResidualPhi           = new TArrayF();
  fResidualEta           = new TArrayF();
  fPIDUtils              = new AliEMCALPIDUtils();

}

//______________________________________________________________________
AliEMCALRecoUtils::AliEMCALRecoUtils(const AliEMCALRecoUtils & reco) 
: TNamed(reco), 
  fParticleType(reco.fParticleType),                         fPosAlgo(reco.fPosAlgo),     fW0(reco.fW0),
  fNonLinearityFunction(reco.fNonLinearityFunction),         fNonLinearThreshold(reco.fNonLinearThreshold),
  fSmearClusterEnergy(reco.fSmearClusterEnergy),             fRandom(),
  fCellsRecalibrated(reco.fCellsRecalibrated),
  fRecalibration(reco.fRecalibration),                       fEMCALRecalibrationFactors(reco.fEMCALRecalibrationFactors),
  fTimeRecalibration(reco.fTimeRecalibration),               fEMCALTimeRecalibrationFactors(reco.fEMCALTimeRecalibrationFactors),
  fUseRunCorrectionFactors(reco.fUseRunCorrectionFactors),   
  fRemoveBadChannels(reco.fRemoveBadChannels),               fRecalDistToBadChannels(reco.fRecalDistToBadChannels),
  fEMCALBadChannelMap(reco.fEMCALBadChannelMap),
  fNCellsFromEMCALBorder(reco.fNCellsFromEMCALBorder),       fNoEMCALBorderAtEta0(reco.fNoEMCALBorderAtEta0),
  fRejectExoticCluster(reco.fRejectExoticCluster),           fRejectExoticCells(reco.fRejectExoticCells), 
  fExoticCellFraction(reco.fExoticCellFraction),             fExoticCellDiffTime(reco.fExoticCellDiffTime),               
  fExoticCellMinAmplitude(reco.fExoticCellMinAmplitude),
  fPIDUtils(reco.fPIDUtils),                                 fAODFilterMask(reco.fAODFilterMask),
  fAODHybridTracks(reco.fAODHybridTracks),                   fAODTPCOnlyTracks(reco.fAODTPCOnlyTracks),
  fMatchedTrackIndex(  reco.fMatchedTrackIndex?  new TArrayI(*reco.fMatchedTrackIndex):0x0),
  fMatchedClusterIndex(reco.fMatchedClusterIndex?new TArrayI(*reco.fMatchedClusterIndex):0x0),
  fResidualEta(        reco.fResidualEta?        new TArrayF(*reco.fResidualEta):0x0),
  fResidualPhi(        reco.fResidualPhi?        new TArrayF(*reco.fResidualPhi):0x0),
  fCutEtaPhiSum(reco.fCutEtaPhiSum),                         fCutEtaPhiSeparate(reco.fCutEtaPhiSeparate), 
  fCutR(reco.fCutR),        fCutEta(reco.fCutEta),           fCutPhi(reco.fCutPhi),
  fClusterWindow(reco.fClusterWindow),
  fMass(reco.fMass),        fStepSurface(reco.fStepSurface), fStepCluster(reco.fStepCluster),
  fITSTrackSA(reco.fITSTrackSA),                             fEMCalSurfaceDistance(440.),
  fTrackCutsType(reco.fTrackCutsType),                       fCutMinTrackPt(reco.fCutMinTrackPt), 
  fCutMinNClusterTPC(reco.fCutMinNClusterTPC),               fCutMinNClusterITS(reco.fCutMinNClusterITS), 
  fCutMaxChi2PerClusterTPC(reco.fCutMaxChi2PerClusterTPC),   fCutMaxChi2PerClusterITS(reco.fCutMaxChi2PerClusterITS),
  fCutRequireTPCRefit(reco.fCutRequireTPCRefit),             fCutRequireITSRefit(reco.fCutRequireITSRefit),
  fCutAcceptKinkDaughters(reco.fCutAcceptKinkDaughters),     fCutMaxDCAToVertexXY(reco.fCutMaxDCAToVertexXY),    
  fCutMaxDCAToVertexZ(reco.fCutMaxDCAToVertexZ),             fCutDCAToVertex2D(reco.fCutDCAToVertex2D),
  fCutRequireITSStandAlone(reco.fCutRequireITSStandAlone),   fCutRequireITSpureSA(reco.fCutRequireITSpureSA)
{
  //Copy ctor
  
  for (Int_t i = 0; i < 15 ; i++) { fMisalRotShift[i]      = reco.fMisalRotShift[i]      ; 
                                   fMisalTransShift[i]    = reco.fMisalTransShift[i]    ; }
  for (Int_t i = 0; i < 7  ; i++) { fNonLinearityParams[i] = reco.fNonLinearityParams[i] ; }
  for (Int_t i = 0; i < 3  ; i++) { fSmearClusterParam[i]  = reco.fSmearClusterParam[i]  ; }

}


//______________________________________________________________________
AliEMCALRecoUtils & AliEMCALRecoUtils::operator = (const AliEMCALRecoUtils & reco) 
{
  //Assignment operator
  
  if (this == &reco)return *this;
  ((TNamed *)this)->operator=(reco);

  for (Int_t i = 0; i < 15 ; i++) { fMisalTransShift[i]    = reco.fMisalTransShift[i]    ; 
                                   fMisalRotShift[i]      = reco.fMisalRotShift[i]      ; }
  for (Int_t i = 0; i < 7  ; i++) { fNonLinearityParams[i] = reco.fNonLinearityParams[i] ; }
  for (Int_t i = 0; i < 3  ; i++) { fSmearClusterParam[i]  = reco.fSmearClusterParam[i]  ; }   
  
  fParticleType              = reco.fParticleType;
  fPosAlgo                   = reco.fPosAlgo; 
  fW0                        = reco.fW0;
  
  fNonLinearityFunction      = reco.fNonLinearityFunction;
  fNonLinearThreshold        = reco.fNonLinearThreshold;
  fSmearClusterEnergy        = reco.fSmearClusterEnergy;

  fCellsRecalibrated         = reco.fCellsRecalibrated;
  fRecalibration             = reco.fRecalibration;
  fEMCALRecalibrationFactors = reco.fEMCALRecalibrationFactors;

  fTimeRecalibration             = reco.fTimeRecalibration;
  fEMCALTimeRecalibrationFactors = reco.fEMCALTimeRecalibrationFactors;

  fUseRunCorrectionFactors   = reco.fUseRunCorrectionFactors;
  
  fRemoveBadChannels         = reco.fRemoveBadChannels;
  fRecalDistToBadChannels    = reco.fRecalDistToBadChannels;
  fEMCALBadChannelMap        = reco.fEMCALBadChannelMap;
  
  fNCellsFromEMCALBorder     = reco.fNCellsFromEMCALBorder;
  fNoEMCALBorderAtEta0       = reco.fNoEMCALBorderAtEta0;
  
  fRejectExoticCluster       = reco.fRejectExoticCluster;           
  fRejectExoticCells         = reco.fRejectExoticCells; 
  fExoticCellFraction        = reco.fExoticCellFraction;
  fExoticCellDiffTime        = reco.fExoticCellDiffTime;              
  fExoticCellMinAmplitude    = reco.fExoticCellMinAmplitude;
  
  fPIDUtils                  = reco.fPIDUtils;

  fAODFilterMask             = reco.fAODFilterMask;
  fAODHybridTracks           = reco.fAODHybridTracks;
  fAODTPCOnlyTracks          = reco.fAODTPCOnlyTracks;
  
  fCutEtaPhiSum              = reco.fCutEtaPhiSum;
  fCutEtaPhiSeparate         = reco.fCutEtaPhiSeparate;
  fCutR                      = reco.fCutR;
  fCutEta                    = reco.fCutEta;
  fCutPhi                    = reco.fCutPhi;
  fClusterWindow             = reco.fClusterWindow;
  fMass                      = reco.fMass;
  fStepSurface               = reco.fStepSurface;
  fStepCluster               = reco.fStepCluster;
  fITSTrackSA                = reco.fITSTrackSA;
  fEMCalSurfaceDistance      = reco.fEMCalSurfaceDistance;
  
  fTrackCutsType             = reco.fTrackCutsType;
  fCutMinTrackPt             = reco.fCutMinTrackPt;
  fCutMinNClusterTPC         = reco.fCutMinNClusterTPC;
  fCutMinNClusterITS         = reco.fCutMinNClusterITS; 
  fCutMaxChi2PerClusterTPC   = reco.fCutMaxChi2PerClusterTPC;
  fCutMaxChi2PerClusterITS   = reco.fCutMaxChi2PerClusterITS;
  fCutRequireTPCRefit        = reco.fCutRequireTPCRefit;
  fCutRequireITSRefit        = reco.fCutRequireITSRefit;
  fCutAcceptKinkDaughters    = reco.fCutAcceptKinkDaughters;
  fCutMaxDCAToVertexXY       = reco.fCutMaxDCAToVertexXY;
  fCutMaxDCAToVertexZ        = reco.fCutMaxDCAToVertexZ;
  fCutDCAToVertex2D          = reco.fCutDCAToVertex2D;
  fCutRequireITSStandAlone   = reco.fCutRequireITSStandAlone; 
  fCutRequireITSpureSA       = reco.fCutRequireITSpureSA;

  if (reco.fResidualEta) {
    // assign or copy construct
    if (fResidualEta) { 
      *fResidualEta = *reco.fResidualEta;
    } else {
      fResidualEta = new TArrayF(*reco.fResidualEta);
    }
  } else {
    if (fResidualEta) delete fResidualEta;
    fResidualEta = 0;
  }
  
  if (reco.fResidualPhi) {
    // assign or copy construct
    if (fResidualPhi) { 
      *fResidualPhi = *reco.fResidualPhi;
    } else {
      fResidualPhi = new TArrayF(*reco.fResidualPhi);
    }
  } else {
    if (fResidualPhi) delete fResidualPhi;
    fResidualPhi = 0;
  }
  
  if (reco.fMatchedTrackIndex) {
    // assign or copy construct
    if (fMatchedTrackIndex) { 
      *fMatchedTrackIndex = *reco.fMatchedTrackIndex;
    } else  { 
      fMatchedTrackIndex = new TArrayI(*reco.fMatchedTrackIndex);
    }
  } else {
    if (fMatchedTrackIndex) delete fMatchedTrackIndex;
    fMatchedTrackIndex = 0;
  }  
  
  if (reco.fMatchedClusterIndex) {
    // assign or copy construct
    if (fMatchedClusterIndex) { 
      *fMatchedClusterIndex = *reco.fMatchedClusterIndex;
    } else {
      fMatchedClusterIndex = new TArrayI(*reco.fMatchedClusterIndex);
    }
  } else {
    if (fMatchedClusterIndex) delete fMatchedClusterIndex;
    fMatchedClusterIndex = 0;
  }
  
  return *this;
}

//_____________________________________
AliEMCALRecoUtils::~AliEMCALRecoUtils()
{
  //Destructor.
  
  if (fEMCALRecalibrationFactors) { 
    fEMCALRecalibrationFactors->Clear();
    delete fEMCALRecalibrationFactors;
  }  
  
  if (fEMCALTimeRecalibrationFactors) { 
    fEMCALTimeRecalibrationFactors->Clear();
    delete fEMCALTimeRecalibrationFactors;
  }  
  
  if (fEMCALBadChannelMap) { 
    fEMCALBadChannelMap->Clear();
    delete fEMCALBadChannelMap;
  }
 
  delete fMatchedTrackIndex   ; 
  delete fMatchedClusterIndex ; 
  delete fResidualEta         ; 
  delete fResidualPhi         ; 
  delete fPIDUtils            ;

  InitTrackCuts();
}

//_______________________________________________________________________________
Bool_t AliEMCALRecoUtils::AcceptCalibrateCell(Int_t absID, Int_t bc,
                                              Float_t  & amp,    Double_t & time, 
                                              AliVCaloCells* cells) 
{
  // Reject cell if criteria not passed and calibrate it
  
  AliEMCALGeometry* geom = AliEMCALGeometry::GetInstance();
  
  if (absID < 0 || absID >= 24*48*geom->GetNumberOfSuperModules()) 
    return kFALSE;
  
  Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1; 
  
  if (!geom->GetCellIndex(absID,imod,iTower,iIphi,iIeta)) {
    // cell absID does not exist
    amp=0; time = 1.e9;
    return kFALSE; 
  }
  
  geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,iphi,ieta);  

  // Do not include bad channels found in analysis,
  if (IsBadChannelsRemovalSwitchedOn() && GetEMCALChannelStatus(imod, ieta, iphi)) {
    return kFALSE;
  }
  
  //Recalibrate energy
  amp  = cells->GetCellAmplitude(absID);
  if (!fCellsRecalibrated && IsRecalibrationOn())
    amp *= GetEMCALChannelRecalibrationFactor(imod,ieta,iphi);
  
  // Recalibrate time
  time = cells->GetCellTime(absID);
  
  RecalibrateCellTime(absID,bc,time);
  
  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliEMCALRecoUtils::CheckCellFiducialRegion(const AliEMCALGeometry* geom, 
                                                  const AliVCluster* cluster, 
                                                  AliVCaloCells* cells) 
{
  // Given the list of AbsId of the cluster, get the maximum cell and 
  // check if there are fNCellsFromBorder from the calorimeter border
  
  if (!cluster)
  {
    AliInfo("Cluster pointer null!");
    return kFALSE;
  }
  
  //If the distance to the border is 0 or negative just exit accept all clusters
  if (cells->GetType()==AliVCaloCells::kEMCALCell && fNCellsFromEMCALBorder <= 0 ) 
    return kTRUE;
  
  Int_t absIdMax  = -1, iSM =-1, ieta = -1, iphi = -1;
  Bool_t shared = kFALSE;
  GetMaxEnergyCell(geom, cells, cluster, absIdMax,  iSM, ieta, iphi, shared);
  
  AliDebug(2,Form("Cluster Max AbsId %d, Cell Energy %2.2f, Cluster Energy %2.2f, Ncells from border %d, EMCAL eta=0 %d\n", 
                  absIdMax, cells->GetCellAmplitude(absIdMax), cluster->E(), fNCellsFromEMCALBorder, fNoEMCALBorderAtEta0));
  
  if (absIdMax==-1) return kFALSE;
  
  //Check if the cell is close to the borders:
  Bool_t okrow = kFALSE;
  Bool_t okcol = kFALSE;
  
  if (iSM < 0 || iphi < 0 || ieta < 0 ) {
    AliFatal(Form("Negative value for super module: %d, or cell ieta: %d, or cell iphi: %d, check EMCAL geometry name\n",
                  iSM,ieta,iphi));
    return kFALSE; // trick coverity
  }
  
  //Check rows/phi
  Int_t iPhiLast = 24;
   if( geom->GetSMType(iSM) == AliEMCALGeometry::kEMCAL_Half ) iPhiLast /= 2;
   else if (  geom->GetSMType(iSM) == AliEMCALGeometry::kEMCAL_3rd ) iPhiLast /= 3;// 1/3 sm case
  
  if(iphi >= fNCellsFromEMCALBorder && iphi < iPhiLast - fNCellsFromEMCALBorder) okrow = kTRUE; 

  //Check columns/eta
  Int_t iEtaLast = 48;
  if(!fNoEMCALBorderAtEta0 || geom->IsDCALSM(iSM)) {// conside inner border
     if(  geom->GetSMType(iSM) == AliEMCALGeometry::kDCAL_Standard )  iEtaLast = iEtaLast*2/3;        
     if(ieta  > fNCellsFromEMCALBorder && ieta < iEtaLast-fNCellsFromEMCALBorder) okcol = kTRUE;  
  } else {
    if (iSM%2==0) {
     if (ieta >= fNCellsFromEMCALBorder)     okcol = kTRUE;  
    } else {
     if(ieta <  iEtaLast-fNCellsFromEMCALBorder)  okcol = kTRUE; 
    }
  }//eta 0 not checked
  
  AliDebug(2,Form("EMCAL Cluster in %d cells fiducial volume: ieta %d, iphi %d, SM %d:  column? %d, row? %d\nq",
                  fNCellsFromEMCALBorder, ieta, iphi, iSM, okcol, okrow));
  
  if (okcol && okrow) {
    //printf("Accept\n");
    return kTRUE;
  } else  {
    //printf("Reject\n");
    AliDebug(2,Form("Reject cluster in border, max cell : ieta %d, iphi %d, SM %d\n",ieta, iphi, iSM));
    return kFALSE;
  }
}  

//_______________________________________________________________________________
Bool_t AliEMCALRecoUtils::ClusterContainsBadChannel(const AliEMCALGeometry* geom, 
                                                    const UShort_t* cellList, 
                                                    Int_t nCells)
{
  // Check that in the cluster cells, there is no bad channel of those stored 
  // in fEMCALBadChannelMap or fPHOSBadChannelMap
  
  if (!fRemoveBadChannels)  return kFALSE;
  if (!fEMCALBadChannelMap) return kFALSE;
  
  Int_t icol = -1;
  Int_t irow = -1;
  Int_t imod = -1;
  for (Int_t iCell = 0; iCell<nCells; iCell++) {
    //Get the column and row
    Int_t iTower = -1, iIphi = -1, iIeta = -1; 
    geom->GetCellIndex(cellList[iCell],imod,iTower,iIphi,iIeta); 
    if (fEMCALBadChannelMap->GetEntries() <= imod) continue;
    geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol);      
    if (GetEMCALChannelStatus(imod, icol, irow)) {
      AliDebug(2,Form("Cluster with bad channel: SM %d, col %d, row %d\n",imod, icol, irow));
      return kTRUE;
    }
  }// cell cluster loop

  return kFALSE;
}


//___________________________________________________________________________
Float_t AliEMCALRecoUtils::GetECross(Int_t absID, Double_t tcell,
                                     AliVCaloCells* cells, Int_t bc)
{
  //Calculate the energy in the cross around the energy given cell
  
  AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
  
  Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1; 
  geom->GetCellIndex(absID,imod,iTower,iIphi,iIeta); 
  geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,iphi,ieta);  
  
  //Get close cells index, energy and time, not in corners
  
  Int_t absID1 = -1;
  Int_t absID2 = -1;
  
  if ( iphi < AliEMCALGeoParams::fgkEMCALRows-1) absID1 = geom-> GetAbsCellIdFromCellIndexes(imod, iphi+1, ieta);
  if ( iphi > 0 )                                absID2 = geom-> GetAbsCellIdFromCellIndexes(imod, iphi-1, ieta);
  
  // In case of cell in eta = 0 border, depending on SM shift the cross cell index
  
  Int_t absID3 = -1;
  Int_t absID4 = -1;
  
  if ( ieta == AliEMCALGeoParams::fgkEMCALCols-1 && !(imod%2) ) {
    absID3 = geom-> GetAbsCellIdFromCellIndexes(imod+1, iphi, 0);
    absID4 = geom-> GetAbsCellIdFromCellIndexes(imod,   iphi, ieta-1); 
  } else if ( ieta == 0 && imod%2 ) {
    absID3 = geom-> GetAbsCellIdFromCellIndexes(imod,   iphi, ieta+1);
    absID4 = geom-> GetAbsCellIdFromCellIndexes(imod-1, iphi, AliEMCALGeoParams::fgkEMCALCols-1); 
  } else {
    if ( ieta < AliEMCALGeoParams::fgkEMCALCols-1 ) 
      absID3 = geom-> GetAbsCellIdFromCellIndexes(imod, iphi, ieta+1);
    if ( ieta > 0 )                                 
      absID4 = geom-> GetAbsCellIdFromCellIndexes(imod, iphi, ieta-1); 
  }
  
  //printf("IMOD %d, AbsId %d, a %d, b %d, c %d e %d \n",imod,absID,absID1,absID2,absID3,absID4);
  
  Float_t  ecell1  = 0, ecell2  = 0, ecell3  = 0, ecell4  = 0;
  Double_t tcell1  = 0, tcell2  = 0, tcell3  = 0, tcell4  = 0;

  AcceptCalibrateCell(absID1,bc, ecell1,tcell1,cells); 
  AcceptCalibrateCell(absID2,bc, ecell2,tcell2,cells); 
  AcceptCalibrateCell(absID3,bc, ecell3,tcell3,cells); 
  AcceptCalibrateCell(absID4,bc, ecell4,tcell4,cells); 
  
  if (TMath::Abs(tcell-tcell1)*1.e9 > fExoticCellDiffTime) ecell1 = 0 ;
  if (TMath::Abs(tcell-tcell2)*1.e9 > fExoticCellDiffTime) ecell2 = 0 ;
  if (TMath::Abs(tcell-tcell3)*1.e9 > fExoticCellDiffTime) ecell3 = 0 ;
  if (TMath::Abs(tcell-tcell4)*1.e9 > fExoticCellDiffTime) ecell4 = 0 ;
  
  return ecell1+ecell2+ecell3+ecell4;
}

//_____________________________________________________________________________________________
Bool_t AliEMCALRecoUtils::IsExoticCell(Int_t absID, AliVCaloCells* cells, Int_t bc)
{
  // Look to cell neighbourhood and reject if it seems exotic
  // Do before recalibrating the cells

  if (!fRejectExoticCells) return kFALSE;
  
  Float_t  ecell  = 0;
  Double_t tcell  = 0;
  Bool_t   accept = AcceptCalibrateCell(absID, bc, ecell ,tcell ,cells); 
  
  if (!accept) return kTRUE; // reject this cell
  
  if (ecell < fExoticCellMinAmplitude) return kFALSE; // do not reject low energy cells

  Float_t eCross = GetECross(absID,tcell,cells,bc);
  
  if (1-eCross/ecell > fExoticCellFraction) {
    AliDebug(2,Form("AliEMCALRecoUtils::IsExoticCell() - EXOTIC CELL id %d, eCell %f, eCross %f, 1-eCross/eCell %f\n",
                    absID,ecell,eCross,1-eCross/ecell));
    return kTRUE;
  }

  return kFALSE;
}

//___________________________________________________________________
Bool_t AliEMCALRecoUtils::IsExoticCluster(const AliVCluster *cluster, 
                                          AliVCaloCells *cells, 
                                          Int_t bc) 
{
  // Check if the cluster highest energy tower is exotic
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return kFALSE;
  }
  
  if (!fRejectExoticCluster) return kFALSE;
  
  // Get highest energy tower
  AliEMCALGeometry* geom = AliEMCALGeometry::GetInstance();
  Int_t iSupMod = -1, absId = -1, ieta = -1, iphi = -1;
  Bool_t shared = kFALSE;
  GetMaxEnergyCell(geom, cells, cluster, absId, iSupMod, ieta, iphi, shared);
  
  return IsExoticCell(absId,cells,bc);
}

//_______________________________________________________________________
Float_t AliEMCALRecoUtils::SmearClusterEnergy(const AliVCluster* cluster) 
{
  //In case of MC analysis, smear energy to match resolution/calibration in real data
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return 0;
  }
  
  Float_t energy    = cluster->E() ;
  Float_t rdmEnergy = energy ;
  if (fSmearClusterEnergy) {
    rdmEnergy = fRandom.Gaus(energy,fSmearClusterParam[0] * TMath::Sqrt(energy) +
                                    fSmearClusterParam[1] * energy +
                                    fSmearClusterParam[2] );
    AliDebug(2, Form("Energy: original %f, smeared %f\n", energy, rdmEnergy));
  }
  
  return rdmEnergy;
}

//____________________________________________________________________________
Float_t AliEMCALRecoUtils::CorrectClusterEnergyLinearity(AliVCluster* cluster)
{
  // Correct cluster energy from non linearity functions
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return 0;
  }
  
  Float_t energy = cluster->E();

  if (energy < 0.05) {
    // Clusters with less than 50 MeV or negative are not possible
    AliInfo(Form("Too Low Cluster energy!, E = %f < 0.05 GeV",energy));
    return 0;
  }
  
  switch (fNonLinearityFunction) 
  {
    case kPi0MC:
    {
      //Non-Linearity correction (from MC with function ([0]*exp(-[1]/E))+(([2]/([3]*2.*TMath::Pi())*exp(-(E-[4])^2/(2.*[3]^2)))))
      //fNonLinearityParams[0] = 1.014;
      //fNonLinearityParams[1] =-0.03329;
      //fNonLinearityParams[2] =-0.3853;
      //fNonLinearityParams[3] = 0.5423;
      //fNonLinearityParams[4] =-0.4335;
       energy *= (fNonLinearityParams[0]*exp(-fNonLinearityParams[1]/energy))+
                  ((fNonLinearityParams[2]/(fNonLinearityParams[3]*2.*TMath::Pi())*
                    exp(-(energy-fNonLinearityParams[4])*(energy-fNonLinearityParams[4])/(2.*fNonLinearityParams[3]*fNonLinearityParams[3]))));
      break;
    }
     
    case kPi0MCv2:
    {
      //Non-Linearity correction (from MC with function [0]/((x+[1])^[2]))+1;
      //fNonLinearityParams[0] = 3.11111e-02;
      //fNonLinearityParams[1] =-5.71666e-02; 
      //fNonLinearityParams[2] = 5.67995e-01;      
      
      energy *= fNonLinearityParams[0]/TMath::Power(energy+fNonLinearityParams[1],fNonLinearityParams[2])+1;
      break;
    }
    
    case kPi0MCv3:
    {
      //Same as beam test corrected, change parameters
      //fNonLinearityParams[0] =  9.81039e-01
      //fNonLinearityParams[1] =  1.13508e-01;
      //fNonLinearityParams[2] =  1.00173e+00; 
      //fNonLinearityParams[3] =  9.67998e-02;
      //fNonLinearityParams[4] =  2.19381e+02;
      //fNonLinearityParams[5] =  6.31604e+01;
      //fNonLinearityParams[6] =  1;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));
      
      break;
    }
      
      
    case kPi0GammaGamma:
    {
      //Non-Linearity correction (from Olga Data with function p0+p1*exp(-p2*E))
      //fNonLinearityParams[0] = 1.04;
      //fNonLinearityParams[1] = -0.1445;
      //fNonLinearityParams[2] = 1.046;
      energy /= (fNonLinearityParams[0]+fNonLinearityParams[1]*exp(-fNonLinearityParams[2]*energy)); //Olga function
      break;
    }
      
    case kPi0GammaConversion:
    {
      //Non-Linearity correction (Nicolas from Dimitri Data with function C*[1-a*exp(-b*E)])
      //fNonLinearityParams[0] = 0.139393/0.1349766;
      //fNonLinearityParams[1] = 0.0566186;
      //fNonLinearityParams[2] = 0.982133;
      energy /= fNonLinearityParams[0]*(1-fNonLinearityParams[1]*exp(-fNonLinearityParams[2]*energy));
      
      break;
    }
      
    case kBeamTest:
    {
      //From beam test, Alexei's results, for different ZS thresholds
      //                        th=30 MeV; th = 45 MeV; th = 75 MeV
      //fNonLinearityParams[0] = 1.007;      1.003;      1.002 
      //fNonLinearityParams[1] = 0.894;      0.719;      0.797 
      //fNonLinearityParams[2] = 0.246;      0.334;      0.358 
      //Rescale the param[0] with 1.03
      energy /= fNonLinearityParams[0]/(1+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]));
      
      break;
    }
      
    case kBeamTestCorrected:
    {
      //From beam test, corrected for material between beam and EMCAL
      //fNonLinearityParams[0] =  0.99078
      //fNonLinearityParams[1] =  0.161499;
      //fNonLinearityParams[2] =  0.655166; 
      //fNonLinearityParams[3] =  0.134101;
      //fNonLinearityParams[4] =  163.282;
      //fNonLinearityParams[5] =  23.6904;
      //fNonLinearityParams[6] =  0.978;
        energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));

      break;
    }
     
    case kBeamTestCorrectedv2:
    {
      //From beam test, corrected for material between beam and EMCAL
      //fNonLinearityParams[0] =  0.983504;
      //fNonLinearityParams[1] =  0.210106;
      //fNonLinearityParams[2] =  0.897274;
      //fNonLinearityParams[3] =  0.0829064;
      //fNonLinearityParams[4] =  152.299;
      //fNonLinearityParams[5] =  31.5028;
      //fNonLinearityParams[6] =  0.968;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));
      
      break;
    }
      
    case kSDMv5:
    {
      //Based on fit to the MC/data using kNoCorrection on the data - utilizes symmetric decay method and kPi0MCv5(MC) - 28 Oct 2013
      //fNonLinearityParams[0] =  1.0;
      //fNonLinearityParams[1] =  6.64778e-02;
      //fNonLinearityParams[2] =  1.570;
      //fNonLinearityParams[3] =  9.67998e-02;
      //fNonLinearityParams[4] =  2.19381e+02;
      //fNonLinearityParams[5] =  6.31604e+01;
      //fNonLinearityParams[6] =  1.01286;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5])))) * (0.964 + exp(-3.132-0.435*energy*2.0));
      
      break;
    }
      
    case kPi0MCv5:
    {
      //Based on comparing MC truth information to the reconstructed energy of clusters. 
      //fNonLinearityParams[0] =  1.0;
      //fNonLinearityParams[1] =  6.64778e-02;
      //fNonLinearityParams[2] =  1.570;
      //fNonLinearityParams[3] =  9.67998e-02;
      //fNonLinearityParams[4] =  2.19381e+02;
      //fNonLinearityParams[5] =  6.31604e+01;
      //fNonLinearityParams[6] =  1.01286;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));
      
      break;
    }
      
    case kSDMv6:
    {
      //Based on fit to the MC/data using kNoCorrection on the data 
      //  - utilizes symmetric decay method and kPi0MCv6(MC) - 09 Dec 2014
      //  - parameters constrained by the test beam data as well
      // described in the note: https://aliceinfo.cern.ch/Notes/node/211 - Sec 3.1.2 (Test Beam Constrained SDM).
      //fNonLinearityParams[0] =  1.0;
      //fNonLinearityParams[1] =  0.237767;
      //fNonLinearityParams[2] =  0.651203;
      //fNonLinearityParams[3] =  0.183741;
      //fNonLinearityParams[4] =  155.427;
      //fNonLinearityParams[5] =  17.0335;
      //fNonLinearityParams[6] =  0.987054;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));
      
      break;
    }
      
    case kPi0MCv6:
    {
      //Based on comparing MC truth information to the reconstructed energy of clusters.
      // described in the note: https://aliceinfo.cern.ch/Notes/node/211 - Sec 3.1.2 (Test Beam Constrained SDM).
      //fNonLinearityParams[0] =  1.0;
      //fNonLinearityParams[1] =  0.0797873;
      //fNonLinearityParams[2] =  1.68322;
      //fNonLinearityParams[3] =  0.0806098;
      //fNonLinearityParams[4] =  244.586;
      //fNonLinearityParams[5] =  116.938;
      //fNonLinearityParams[6] =  1.00437;
      energy *= fNonLinearityParams[6]/(fNonLinearityParams[0]*(1./(1.+fNonLinearityParams[1]*exp(-energy/fNonLinearityParams[2]))*1./(1.+fNonLinearityParams[3]*exp((energy-fNonLinearityParams[4])/fNonLinearityParams[5]))));
      
      break;
    }
      
    case kNoCorrection:
      AliDebug(2,"No correction on the energy\n");
      break;
      
  }

  return energy;
}

//__________________________________________________
void AliEMCALRecoUtils::InitNonLinearityParam()
{
  //Initialising Non Linearity Parameters
  
  if (fNonLinearityFunction == kPi0MC) {
    fNonLinearityParams[0] = 1.014;
    fNonLinearityParams[1] = -0.03329;
    fNonLinearityParams[2] = -0.3853;
    fNonLinearityParams[3] = 0.5423;
    fNonLinearityParams[4] = -0.4335;
  }
  
  if (fNonLinearityFunction == kPi0MCv2) {
    fNonLinearityParams[0] = 3.11111e-02;
    fNonLinearityParams[1] =-5.71666e-02; 
    fNonLinearityParams[2] = 5.67995e-01;      
  }
  
  if (fNonLinearityFunction == kPi0MCv3) {
    fNonLinearityParams[0] =  9.81039e-01;
    fNonLinearityParams[1] =  1.13508e-01;
    fNonLinearityParams[2] =  1.00173e+00; 
    fNonLinearityParams[3] =  9.67998e-02;
    fNonLinearityParams[4] =  2.19381e+02;
    fNonLinearityParams[5] =  6.31604e+01;
    fNonLinearityParams[6] =  1;
  }
  
  if (fNonLinearityFunction == kPi0GammaGamma) {
    fNonLinearityParams[0] = 1.04;
    fNonLinearityParams[1] = -0.1445;
    fNonLinearityParams[2] = 1.046;
  }  

  if (fNonLinearityFunction == kPi0GammaConversion) {
    fNonLinearityParams[0] = 0.139393;
    fNonLinearityParams[1] = 0.0566186;
    fNonLinearityParams[2] = 0.982133;
  }  

  if (fNonLinearityFunction == kBeamTest) {
    if (fNonLinearThreshold == 30) {
      fNonLinearityParams[0] = 1.007; 
      fNonLinearityParams[1] = 0.894; 
      fNonLinearityParams[2] = 0.246; 
    }
    if (fNonLinearThreshold == 45) {
      fNonLinearityParams[0] = 1.003; 
      fNonLinearityParams[1] = 0.719; 
      fNonLinearityParams[2] = 0.334; 
    }
    if (fNonLinearThreshold == 75) {
      fNonLinearityParams[0] = 1.002; 
      fNonLinearityParams[1] = 0.797; 
      fNonLinearityParams[2] = 0.358; 
    }
  }

  if (fNonLinearityFunction == kBeamTestCorrected) {
    fNonLinearityParams[0] =  0.99078;
    fNonLinearityParams[1] =  0.161499;
    fNonLinearityParams[2] =  0.655166; 
    fNonLinearityParams[3] =  0.134101;
    fNonLinearityParams[4] =  163.282;
    fNonLinearityParams[5] =  23.6904;
    fNonLinearityParams[6] =  0.978;
  }
  
  if (fNonLinearityFunction == kBeamTestCorrectedv2) {
    fNonLinearityParams[0] =  0.983504;
    fNonLinearityParams[1] =  0.210106;
    fNonLinearityParams[2] =  0.897274;
    fNonLinearityParams[3] =  0.0829064;
    fNonLinearityParams[4] =  152.299;
    fNonLinearityParams[5] =  31.5028;
    fNonLinearityParams[6] =  0.968;
  }

  if (fNonLinearityFunction == kSDMv5) {
    fNonLinearityParams[0] =  1.0;
    fNonLinearityParams[1] =  6.64778e-02;
    fNonLinearityParams[2] =  1.570;
    fNonLinearityParams[3] =  9.67998e-02;
    fNonLinearityParams[4] =  2.19381e+02;
    fNonLinearityParams[5] =  6.31604e+01;
    fNonLinearityParams[6] =  1.01286;
  }

  if (fNonLinearityFunction == kPi0MCv5) {
    fNonLinearityParams[0] =  1.0;
    fNonLinearityParams[1] =  6.64778e-02;
    fNonLinearityParams[2] =  1.570;
    fNonLinearityParams[3] =  9.67998e-02;
    fNonLinearityParams[4] =  2.19381e+02;
    fNonLinearityParams[5] =  6.31604e+01;
    fNonLinearityParams[6] =  1.01286;
  }

  if (fNonLinearityFunction == kSDMv6) {
    fNonLinearityParams[0] = 1.0;      
    fNonLinearityParams[1] = 0.237767; 
    fNonLinearityParams[2] = 0.651203; 
    fNonLinearityParams[3] = 0.183741; 
    fNonLinearityParams[4] = 155.427;  
    fNonLinearityParams[5] = 17.0335;  
    fNonLinearityParams[6] = 0.987054; 
  }

  if (fNonLinearityFunction == kPi0MCv6) {
    fNonLinearityParams[0] = 1.0;       
    fNonLinearityParams[1] = 0.0797873; 
    fNonLinearityParams[2] = 1.68322;   
    fNonLinearityParams[3] = 0.0806098; 
    fNonLinearityParams[4] = 244.586;   
    fNonLinearityParams[5] = 116.938;   
    fNonLinearityParams[6] = 1.00437;   
  }

}

//_________________________________________________________
Float_t  AliEMCALRecoUtils::GetDepth(Float_t energy, 
                                     Int_t iParticle, 
                                     Int_t iSM) const 
{
  //Calculate shower depth for a given cluster energy and particle type

  // parameters 
  Float_t x0    = 1.31;
  Float_t ecr   = 8;
  Float_t depth = 0;
  Float_t arg   = energy*1000/ ecr; //Multiply energy by 1000 to transform to MeV
  
  switch ( iParticle )
  {
    case kPhoton:
      if (arg < 1) 
	depth = 0;
      else
	depth = x0 * (TMath::Log(arg) + 0.5); 
      break;
      
    case kElectron:
      if (arg < 1) 
	depth = 0;
      else
	depth = x0 * (TMath::Log(arg) - 0.5); 
      break;
      
    case kHadron:
      // hadron 
      // boxes anc. here
      if (gGeoManager) {
        gGeoManager->cd("ALIC_1/XEN1_1");
        TGeoNode        *geoXEn1    = gGeoManager->GetCurrentNode();
        TGeoNodeMatrix  *geoSM      = dynamic_cast<TGeoNodeMatrix *>(geoXEn1->GetDaughter(iSM));
        if (geoSM) {
          TGeoVolume      *geoSMVol   = geoSM->GetVolume(); 
          TGeoShape       *geoSMShape = geoSMVol->GetShape();
          TGeoBBox        *geoBox     = dynamic_cast<TGeoBBox *>(geoSMShape);
          if (geoBox) depth = 0.5 * geoBox->GetDX()*2 ;
          else AliFatal("Null GEANT box");
        }
        else AliFatal("NULL  GEANT node matrix");
      }
      else
      {//electron
	if (arg < 1) 
	  depth = 0;
	else
	  depth = x0 * (TMath::Log(arg) - 0.5); 
      }
        
      break;
      
    default://photon
      if (arg < 1) 
	depth = 0;
      else
	depth = x0 * (TMath::Log(arg) + 0.5);
  }  
  
  return depth;
}

//____________________________________________________________________
void AliEMCALRecoUtils::GetMaxEnergyCell(const AliEMCALGeometry *geom, 
                                         AliVCaloCells* cells, 
                                         const AliVCluster* clu, 
                                         Int_t  & absId,  
                                         Int_t  & iSupMod, 
                                         Int_t  & ieta, 
                                         Int_t  & iphi, 
                                         Bool_t & shared)
{
  //For a given CaloCluster gets the absId of the cell 
  //with maximum energy deposit.
  
  Double_t eMax        = -1.;
  Double_t eCell       = -1.;
  Float_t  fraction    = 1.;
  Float_t  recalFactor = 1.;
  Int_t    cellAbsId   = -1 ;

  Int_t iTower  = -1;
  Int_t iIphi   = -1;
  Int_t iIeta   = -1;
  Int_t iSupMod0= -1;

  if (!clu) {
    AliInfo("Cluster pointer null!");
    absId=-1; iSupMod0=-1, ieta = -1; iphi = -1; shared = -1;
    return;
  }
  
  for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) {
    cellAbsId = clu->GetCellAbsId(iDig);
    fraction  = clu->GetCellAmplitudeFraction(iDig);
    //printf("a Cell %d, id, %d, amp %f, fraction %f\n",iDig,cellAbsId,cells->GetCellAmplitude(cellAbsId),fraction);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off
    geom->GetCellIndex(cellAbsId,iSupMod,iTower,iIphi,iIeta); 
    geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi, iIeta,iphi,ieta);
    if (iDig==0) {
      iSupMod0=iSupMod;
    } else if (iSupMod0!=iSupMod)  {
      shared = kTRUE;
      //printf("AliEMCALRecoUtils::GetMaxEnergyCell() - SHARED CLUSTER\n");
    }
    if (!fCellsRecalibrated && IsRecalibrationOn()) {
      recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
    }
    eCell  = cells->GetCellAmplitude(cellAbsId)*fraction*recalFactor;
    //printf("b Cell %d, id, %d, amp %f, fraction %f\n",iDig,cellAbsId,eCell,fraction);
    if (eCell > eMax) { 
      eMax  = eCell; 
      absId = cellAbsId;
      //printf("\t new max: cell %d, e %f, ecell %f\n",maxId, eMax,eCell);
    }
  }// cell loop
  
  //Get from the absid the supermodule, tower and eta/phi numbers
  geom->GetCellIndex(absId,iSupMod,iTower,iIphi,iIeta); 
  //Gives SuperModule and Tower numbers
  geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,
                                         iIphi, iIeta,iphi,ieta); 
  //printf("Max id %d, iSM %d, col %d, row %d\n",absId,iSupMod,ieta,iphi);
  //printf("Max end---\n");
}

//______________________________________
void AliEMCALRecoUtils::InitParameters()
{
  // Initialize data members with default values
  
  fParticleType = kPhoton;
  fPosAlgo      = kUnchanged;
  fW0           = 4.5;
  
  fNonLinearityFunction = kNoCorrection;
  fNonLinearThreshold   = 30;
  
  fExoticCellFraction     = 0.97;
  fExoticCellDiffTime     = 1e6;
  fExoticCellMinAmplitude = 4.0;
  
  fAODFilterMask    = 128;
  fAODHybridTracks  = kFALSE;
  fAODTPCOnlyTracks = kTRUE;
  
  fCutEtaPhiSum      = kTRUE;
  fCutEtaPhiSeparate = kFALSE;
  
  fCutR   = 0.05; 
  fCutEta = 0.025; 
  fCutPhi = 0.05;
  
  fClusterWindow = 100;
  fMass          = 0.139;
  
  fStepSurface   = 20.;                      
  fStepCluster   = 5.;
  fTrackCutsType = kLooseCut;
  
  fCutMinTrackPt     = 0;
  fCutMinNClusterTPC = -1;
  fCutMinNClusterITS = -1;
  
  fCutMaxChi2PerClusterTPC  = 1e10;
  fCutMaxChi2PerClusterITS  = 1e10;
  
  fCutRequireTPCRefit     = kFALSE;
  fCutRequireITSRefit     = kFALSE;
  fCutAcceptKinkDaughters = kFALSE;
  
  fCutMaxDCAToVertexXY = 1e10;             
  fCutMaxDCAToVertexZ  = 1e10;              
  fCutDCAToVertex2D    = kFALSE;
  
  fCutRequireITSStandAlone = kFALSE; //MARCEL
  fCutRequireITSpureSA     = kFALSE; //Marcel
  
  //Misalignment matrices
  for (Int_t i = 0; i < 15 ; i++) 
  {
    fMisalTransShift[i] = 0.; 
    fMisalRotShift[i]   = 0.; 
  }
  
  //Non linearity
  for (Int_t i = 0; i < 7  ; i++) fNonLinearityParams[i] = 0.; 
  
  //For kBeamTestCorrectedv2 case, but default is no correction
  fNonLinearityParams[0] =  0.983504;
  fNonLinearityParams[1] =  0.210106;
  fNonLinearityParams[2] =  0.897274;
  fNonLinearityParams[3] =  0.0829064;
  fNonLinearityParams[4] =  152.299;
  fNonLinearityParams[5] =  31.5028;
  fNonLinearityParams[6] =  0.968;
  
  //Cluster energy smearing
  fSmearClusterEnergy   = kFALSE;
  fSmearClusterParam[0] = 0.07; // * sqrt E term
  fSmearClusterParam[1] = 0.00; // * E term
  fSmearClusterParam[2] = 0.00; // constant
}

//_____________________________________________________
void AliEMCALRecoUtils::InitEMCALRecalibrationFactors()
{
  //Init EMCAL recalibration factors
  AliDebug(2,"AliCalorimeterUtils::InitEMCALRecalibrationFactors()");
  //In order to avoid rewriting the same histograms
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  fEMCALRecalibrationFactors = new TObjArray(12);
  for (int i = 0; i < 12; i++) 
    fEMCALRecalibrationFactors->Add(new TH2F(Form("EMCALRecalFactors_SM%d",i),
                                             Form("EMCALRecalFactors_SM%d",i),  48, 0, 48, 24, 0, 24));
  //Init the histograms with 1
  for (Int_t sm = 0; sm < 12; sm++) 
  {
    for (Int_t i = 0; i < 48; i++) 
    {
      for (Int_t j = 0; j < 24; j++) 
      {
        SetEMCALChannelRecalibrationFactor(sm,i,j,1.);
      }
    }
  }
  
  fEMCALRecalibrationFactors->SetOwner(kTRUE);
  fEMCALRecalibrationFactors->Compress();
  
  //In order to avoid rewriting the same histograms
  TH1::AddDirectory(oldStatus);    
}

//_________________________________________________________
void AliEMCALRecoUtils::InitEMCALTimeRecalibrationFactors()
{
  //Init EMCAL recalibration factors
  AliDebug(2,"AliCalorimeterUtils::InitEMCALRecalibrationFactors()");
  //In order to avoid rewriting the same histograms
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  fEMCALTimeRecalibrationFactors = new TObjArray(4);
  for (int i = 0; i < 4; i++) 
    fEMCALTimeRecalibrationFactors->Add(new TH1F(Form("hAllTimeAvBC%d",i),
                                                 Form("hAllTimeAvBC%d",i),  
                                                 48*24*12,0.,48*24*12)          );
  //Init the histograms with 1
  for (Int_t bc = 0; bc < 4; bc++) 
  {
    for (Int_t i = 0; i < 48*24*12; i++) 
      SetEMCALChannelTimeRecalibrationFactor(bc,i,0.);
  }
  
  fEMCALTimeRecalibrationFactors->SetOwner(kTRUE);
  fEMCALTimeRecalibrationFactors->Compress();
  
  //In order to avoid rewriting the same histograms
  TH1::AddDirectory(oldStatus);    
}

//____________________________________________________
void AliEMCALRecoUtils::InitEMCALBadChannelStatusMap()
{
  //Init EMCAL bad channels map
  AliDebug(2,"AliEMCALRecoUtils::InitEMCALBadChannelStatusMap()");
  //In order to avoid rewriting the same histograms
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  fEMCALBadChannelMap = new TObjArray(12);
  //TH2F * hTemp = new  TH2I("EMCALBadChannelMap","EMCAL SuperModule bad channel map", 48, 0, 48, 24, 0, 24);
  for (int i = 0; i < 12; i++) 
  {
    fEMCALBadChannelMap->Add(new TH2I(Form("EMCALBadChannelMap_Mod%d",i),Form("EMCALBadChannelMap_Mod%d",i), 48, 0, 48, 24, 0, 24));
  }
  
  fEMCALBadChannelMap->SetOwner(kTRUE);
  fEMCALBadChannelMap->Compress();
  
  //In order to avoid rewriting the same histograms
  TH1::AddDirectory(oldStatus);    
}

//____________________________________________________________________________
void AliEMCALRecoUtils::RecalibrateClusterEnergy(const AliEMCALGeometry* geom, 
                                                 AliVCluster * cluster, 
                                                 AliVCaloCells * cells, 
                                                 Int_t bc)
{
  // Recalibrate the cluster energy and Time, considering the recalibration map 
  // and the energy of the cells and time that compose the cluster.
  // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber();
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return;
  }  
  
  //Get the cluster number of cells and list of absId, check what kind of cluster do we have.
  UShort_t * index    = cluster->GetCellsAbsId() ;
  Double_t * fraction = cluster->GetCellsAmplitudeFraction() ;
  Int_t ncells = cluster->GetNCells();
  
  //Initialize some used variables
  Float_t energy = 0;
  Int_t   absId  =-1;
  Int_t   icol   =-1, irow =-1, imod=1;
  Float_t factor = 1, frac = 0;
  Int_t   absIdMax = -1;
  Float_t emax     = 0;
  
  //Loop on the cells, get the cell amplitude and recalibration factor, multiply and and to the new energy
  for (Int_t icell = 0; icell < ncells; icell++)
  {
    absId = index[icell];
    frac =  fraction[icell];
    if (frac < 1e-5) frac = 1; //in case of EMCAL, this is set as 0 since unfolding is off
    
    if (!fCellsRecalibrated && IsRecalibrationOn()) {
      // Energy  
      Int_t iTower = -1, iIphi = -1, iIeta = -1; 
      geom->GetCellIndex(absId,imod,iTower,iIphi,iIeta); 
      if (fEMCALRecalibrationFactors->GetEntries() <= imod) 
	continue;
      geom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol);      
      factor = GetEMCALChannelRecalibrationFactor(imod,icol,irow);
      
      AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - recalibrate cell: module %d, col %d, row %d, cell fraction %f,recalibration factor %f, cell energy %f\n",
                      imod,icol,irow,frac,factor,cells->GetCellAmplitude(absId)));
      
    } 
    
    energy += cells->GetCellAmplitude(absId)*factor*frac;
    
    if (emax < cells->GetCellAmplitude(absId)*factor*frac) {
      emax     = cells->GetCellAmplitude(absId)*factor*frac;
      absIdMax = absId;
    }
  }
  
  AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - Energy before %f, after %f \n",cluster->E(),energy));

  cluster->SetE(energy);

  // Recalculate time of cluster
  Double_t timeorg = cluster->GetTOF();

  Double_t time = cells->GetCellTime(absIdMax);
  if (!fCellsRecalibrated && IsTimeRecalibrationOn())
    RecalibrateCellTime(absIdMax,bc,time);

  cluster->SetTOF(time);

  AliDebug(2,Form("AliEMCALRecoUtils::RecalibrateClusterEnergy - Time before %f, after %f \n",timeorg,cluster->GetTOF()));
}

//_____________________________________________________________
void AliEMCALRecoUtils::RecalibrateCells(AliVCaloCells * cells,
                                         Int_t bc)
{
  // Recalibrate the cells time and energy, considering the recalibration map and the energy 
  // of the cells that compose the cluster.
  // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber();

  if (!IsRecalibrationOn() && !IsTimeRecalibrationOn() && !IsBadChannelsRemovalSwitchedOn()) 
    return;
  
  if (!cells) {
    AliInfo("Cells pointer null!");
    return;
  }  
  
  Short_t  absId  =-1;
  Bool_t   accept = kFALSE;
  Float_t  ecell  = 0;
  Double_t tcell  = 0;
  Double_t ecellin = 0;
  Double_t tcellin = 0;
  Int_t  mclabel = -1;
  Double_t efrac = 0;
  
  Int_t nEMcell  = cells->GetNumberOfCells() ;  
  for (Int_t iCell = 0; iCell < nEMcell; iCell++) 
  { 
    cells->GetCell( iCell, absId, ecellin, tcellin, mclabel, efrac );
    
    accept = AcceptCalibrateCell(absId, bc, ecell ,tcell ,cells); 
    if (!accept) {
      ecell = 0;
      tcell = -1;
    }
    
    //Set new values
    cells->SetCell(iCell,absId,ecell, tcell, mclabel, efrac);
  }

  fCellsRecalibrated = kTRUE;
}

//_______________________________________________________________________________________________________
void AliEMCALRecoUtils::RecalibrateCellTime(Int_t absId, Int_t bc, Double_t & celltime) const
{
  // Recalibrate time of cell with absID  considering the recalibration map 
  // bc= bunch crossing number returned by esdevent->GetBunchCrossNumber();
  
  if (!fCellsRecalibrated && IsTimeRecalibrationOn() && bc >= 0) {
    celltime -= GetEMCALChannelTimeRecalibrationFactor(bc%4,absId)*1.e-9;    ;  
  }
}
  
//______________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterPosition(const AliEMCALGeometry *geom, 
                                                   AliVCaloCells* cells, 
                                                   AliVCluster* clu)
{
  //For a given CaloCluster recalculates the position for a given set of misalignment shifts and puts it again in the CaloCluster.
  
  if (!clu) {
    AliInfo("Cluster pointer null!");
    return;
  }
    
  if      (fPosAlgo==kPosTowerGlobal) RecalculateClusterPositionFromTowerGlobal( geom, cells, clu);
  else if (fPosAlgo==kPosTowerIndex)  RecalculateClusterPositionFromTowerIndex ( geom, cells, clu);
  else    AliDebug(2,"Algorithm to recalculate position not selected, do nothing.");
}  

//_____________________________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterPositionFromTowerGlobal(const AliEMCALGeometry *geom, 
                                                                  AliVCaloCells* cells, 
                                                                  AliVCluster* clu)
{
  // For a given CaloCluster recalculates the position for a given set of misalignment shifts and puts it again in the CaloCluster.
  // The algorithm is a copy of what is done in AliEMCALRecPoint
  
  Double_t eCell       = 0.;
  Float_t  fraction    = 1.;
  Float_t  recalFactor = 1.;
  
  Int_t    absId   = -1;
  Int_t    iTower  = -1, iIphi  = -1, iIeta  = -1;
  Int_t    iSupModMax = -1, iSM=-1, iphi   = -1, ieta   = -1;
  Float_t  weight = 0.,  totalWeight=0.;
  Float_t  newPos[3] = {0,0,0};
  Double_t pLocal[3], pGlobal[3];
  Bool_t shared = kFALSE;

  Float_t  clEnergy = clu->E(); //Energy already recalibrated previously
  if (clEnergy <= 0)
    return;
  GetMaxEnergyCell(geom, cells, clu, absId,  iSupModMax, ieta, iphi,shared);
  Double_t depth = GetDepth(clEnergy,fParticleType,iSupModMax) ;
  
  //printf("** Cluster energy %f, ncells %d, depth %f\n",clEnergy,clu->GetNCells(),depth);
  
  for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) 
  {
    absId = clu->GetCellAbsId(iDig);
    fraction  = clu->GetCellAmplitudeFraction(iDig);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off
    
    if (!fCellsRecalibrated) {
      geom->GetCellIndex(absId,iSM,iTower,iIphi,iIeta); 
      geom->GetCellPhiEtaIndexInSModule(iSM,iTower,iIphi, iIeta,iphi,ieta);      
      if (IsRecalibrationOn()) {
        recalFactor = GetEMCALChannelRecalibrationFactor(iSM,ieta,iphi);
      }
    }
    
    eCell  = cells->GetCellAmplitude(absId)*fraction*recalFactor;
    
    weight = GetCellWeight(eCell,clEnergy);
    totalWeight += weight;
    
    geom->RelPosCellInSModule(absId,depth,pLocal[0],pLocal[1],pLocal[2]);
    //printf("pLocal (%f,%f,%f), SM %d, absId %d\n",pLocal[0],pLocal[1],pLocal[2],iSupModMax,absId);
    geom->GetGlobal(pLocal,pGlobal,iSupModMax);
    //printf("pLocal (%f,%f,%f)\n",pGlobal[0],pGlobal[1],pGlobal[2]);

    for (int i=0; i<3; i++ ) newPos[i] += (weight*pGlobal[i]);
  }// cell loop
  
  if (totalWeight>0) {
    for (int i=0; i<3; i++ )    newPos[i] /= totalWeight;
  }
    
  //Float_t pos[]={0,0,0};
  //clu->GetPosition(pos);
  //printf("OldPos  : %2.3f,%2.3f,%2.3f\n",pos[0],pos[1],pos[2]);
  //printf("NewPos  : %2.3f,%2.3f,%2.3f\n",newPos[0],newPos[1],newPos[2]);
  
  if (iSupModMax > 1) { //sector 1
    newPos[0] +=fMisalTransShift[3];//-=3.093; 
    newPos[1] +=fMisalTransShift[4];//+=6.82;
    newPos[2] +=fMisalTransShift[5];//+=1.635;
    //printf("   +    : %2.3f,%2.3f,%2.3f\n",fMisalTransShift[3],fMisalTransShift[4],fMisalTransShift[5]);
  } else { //sector 0
    newPos[0] +=fMisalTransShift[0];//+=1.134;
    newPos[1] +=fMisalTransShift[1];//+=8.2;
    newPos[2] +=fMisalTransShift[2];//+=1.197;
    //printf("   +    : %2.3f,%2.3f,%2.3f\n",fMisalTransShift[0],fMisalTransShift[1],fMisalTransShift[2]);
  }
  //printf("NewPos : %2.3f,%2.3f,%2.3f\n",newPos[0],newPos[1],newPos[2]);

  clu->SetPosition(newPos);
}  

//____________________________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterPositionFromTowerIndex(const AliEMCALGeometry *geom, 
                                                                 AliVCaloCells* cells, 
                                                                 AliVCluster* clu)
{
  // For a given CaloCluster recalculates the position for a given set of misalignment shifts and puts it again in the CaloCluster.
  // The algorithm works with the tower indeces, averages the indeces and from them it calculates the global position
  
  Double_t eCell       = 1.;
  Float_t  fraction    = 1.;
  Float_t  recalFactor = 1.;
  
  Int_t absId   = -1;
  Int_t iTower  = -1;
  Int_t iIphi   = -1, iIeta   = -1;
  Int_t iSupMod = -1, iSupModMax = -1;
  Int_t iphi = -1, ieta =-1;
  Bool_t shared = kFALSE;

  Float_t clEnergy = clu->E(); //Energy already recalibrated previously.
  
  if (clEnergy <= 0)
    return;
  GetMaxEnergyCell(geom, cells, clu, absId,  iSupModMax, ieta, iphi,shared);
  Float_t  depth = GetDepth(clEnergy,fParticleType,iSupMod) ;

  Float_t weight = 0., weightedCol = 0., weightedRow = 0., totalWeight=0.;
  Bool_t areInSameSM = kTRUE; //exclude clusters with cells in different SMs for now
  Int_t startingSM = -1;
  
  for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) 
  {
    absId = clu->GetCellAbsId(iDig);
    fraction  = clu->GetCellAmplitudeFraction(iDig);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off

    if      (iDig==0)  startingSM = iSupMod;
    else if (iSupMod != startingSM) areInSameSM = kFALSE;

    eCell  = cells->GetCellAmplitude(absId);
    
    geom->GetCellIndex(absId,iSupMod,iTower,iIphi,iIeta); 
    geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi, iIeta,iphi,ieta);    
    
    if (!fCellsRecalibrated)
    {
      if (IsRecalibrationOn()) {
        recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
      }
    }
    
    eCell  = cells->GetCellAmplitude(absId)*fraction*recalFactor;
    
    weight = GetCellWeight(eCell,clEnergy);
    if (weight < 0) weight = 0;
    totalWeight += weight;
    weightedCol += ieta*weight;
    weightedRow += iphi*weight;
    
    //printf("Max cell? cell %d, amplitude org %f, fraction %f, recalibration %f, amplitude new %f \n",cellAbsId, cells->GetCellAmplitude(cellAbsId), fraction, recalFactor, eCell) ;
  }// cell loop
    
  Float_t xyzNew[]={0.,0.,0.};
  if (areInSameSM == kTRUE) {
    //printf("In Same SM\n");
    weightedCol = weightedCol/totalWeight;
    weightedRow = weightedRow/totalWeight;
    geom->RecalculateTowerPosition(weightedRow, weightedCol, iSupModMax, depth, fMisalTransShift, fMisalRotShift, xyzNew); 
  } 
  else 
  {
    //printf("In Different SM\n");
    geom->RecalculateTowerPosition(iphi,        ieta,        iSupModMax, depth, fMisalTransShift, fMisalRotShift, xyzNew); 
  }
  
  clu->SetPosition(xyzNew);
}

//___________________________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterDistanceToBadChannel(const AliEMCALGeometry * geom, 
                                                               AliVCaloCells* cells, 
                                                               AliVCluster * cluster)
{           
  //re-evaluate distance to bad channel with updated bad map
  
  if (!fRecalDistToBadChannels) return;
  
  if (!cluster)
  {
    AliInfo("Cluster pointer null!");
    return;
  }  
  
  //Get channels map of the supermodule where the cluster is.
  Int_t absIdMax  = -1, iSupMod =-1, icolM = -1, irowM = -1;
  Bool_t shared = kFALSE;
  GetMaxEnergyCell(geom, cells, cluster, absIdMax,  iSupMod, icolM, irowM, shared);
  TH2D* hMap  = (TH2D*)fEMCALBadChannelMap->At(iSupMod);

  Int_t dRrow, dRcol;  
  Float_t  minDist = 10000.;
  Float_t  dist    = 0.;
  
  //Loop on tower status map 
  for (Int_t irow = 0; irow < AliEMCALGeoParams::fgkEMCALRows; irow++)
  {
    for (Int_t icol = 0; icol < AliEMCALGeoParams::fgkEMCALCols; icol++)
    {
      //Check if tower is bad.
      if (hMap->GetBinContent(icol,irow)==0) continue;
      //printf("AliEMCALRecoUtils::RecalculateDistanceToBadChannels() - \n \t Bad channel in SM %d, col %d, row %d, \n \t Cluster max in col %d, row %d\n",
      //       iSupMod,icol, irow, icolM,irowM);
      
      dRrow=TMath::Abs(irowM-irow);
      dRcol=TMath::Abs(icolM-icol);
      dist=TMath::Sqrt(dRrow*dRrow+dRcol*dRcol);
      if (dist < minDist)
      {
        //printf("MIN DISTANCE TO BAD %2.2f\n",dist);
        minDist = dist;
      }
    }
  }
  
  //In case the cluster is shared by 2 SuperModules, need to check the map of the second Super Module
  if (shared) 
  {
    TH2D* hMap2 = 0;
    Int_t iSupMod2 = -1;
    
    //The only possible combinations are (0,1), (2,3) ... (8,9)
    if (iSupMod%2) iSupMod2 = iSupMod-1;
    else           iSupMod2 = iSupMod+1;
    hMap2  = (TH2D*)fEMCALBadChannelMap->At(iSupMod2);
    
    //Loop on tower status map of second super module
    for (Int_t irow = 0; irow < AliEMCALGeoParams::fgkEMCALRows; irow++)
    {
      for (Int_t icol = 0; icol < AliEMCALGeoParams::fgkEMCALCols; icol++)
      {
        //Check if tower is bad.
        if (hMap2->GetBinContent(icol,irow)==0) 
	  continue;
        //printf("AliEMCALRecoUtils::RecalculateDistanceToBadChannels(shared) - \n \t Bad channel in SM %d, col %d, row %d \n \t Cluster max in SM %d, col %d, row %d\n",
        //     iSupMod2,icol, irow,iSupMod,icolM,irowM);
        dRrow=TMath::Abs(irow-irowM);
        
        if (iSupMod%2) {
          dRcol=TMath::Abs(icol-(AliEMCALGeoParams::fgkEMCALCols+icolM));
        } else {
          dRcol=TMath::Abs(AliEMCALGeoParams::fgkEMCALCols+icol-icolM);
        }                    
        
        dist=TMath::Sqrt(dRrow*dRrow+dRcol*dRcol);
        if (dist < minDist) minDist = dist;        
      }
    }
  }// shared cluster in 2 SuperModules
  
  AliDebug(2,Form("Max cluster cell (SM,col,row)=(%d %d %d) - Distance to Bad Channel %2.2f",iSupMod, icolM, irowM, minDist));
  cluster->SetDistanceToBadChannel(minDist);
}

//__________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterPID(AliVCluster * cluster)
{           
  //re-evaluate identification parameters with bayesian
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return;
  }
  
  if (cluster->GetM02() != 0)
    fPIDUtils->ComputePID(cluster->E(),cluster->GetM02());
  
  Float_t pidlist[AliPID::kSPECIESCN+1];
  for (Int_t i = 0; i < AliPID::kSPECIESCN+1; i++) pidlist[i] = fPIDUtils->GetPIDFinal(i);
        
  cluster->SetPID(pidlist);
}

//___________________________________________________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, 
                                                                AliVCaloCells* cells, 
                                                                AliVCluster * cluster,
                                                                Float_t & l0,   Float_t & l1,   
                                                                Float_t & disp, Float_t & dEta, Float_t & dPhi,
                                                                Float_t & sEta, Float_t & sPhi, Float_t & sEtaPhi)
{
  // Calculates new center of gravity in the local EMCAL-module coordinates 
  // and tranfers into global ALICE coordinates
  // Calculates Dispersion and main axis
  
  if (!cluster) {
    AliInfo("Cluster pointer null!");
    return;
  }
    
  Double_t eCell       = 0.;
  Float_t  fraction    = 1.;
  Float_t  recalFactor = 1.;

  Int_t    iSupMod = -1;
  Int_t    iTower  = -1;
  Int_t    iIphi   = -1;
  Int_t    iIeta   = -1;
  Int_t    iphi    = -1;
  Int_t    ieta    = -1;
  Double_t etai    = -1.;
  Double_t phii    = -1.;
  
  Int_t    nstat   = 0 ;
  Float_t  wtot    = 0.;
  Double_t w       = 0.;
  Double_t etaMean = 0.;
  Double_t phiMean = 0.;
  
  //Loop on cells, calculate the cluster energy, in case a cut on cell energy is added
  // and to check if the cluster is between 2 SM in eta
  Int_t   iSM0   = -1;
  Bool_t  shared = kFALSE;
  Float_t energy = 0;
  
  for (Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
  {
    //Get from the absid the supermodule, tower and eta/phi numbers
    geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
    geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
    
    //Check if there are cells of different SM
    if      (iDigit == 0   ) iSM0 = iSupMod;
    else if (iSupMod!= iSM0) shared = kTRUE;
    
    //Get the cell energy, if recalibration is on, apply factors
    fraction  = cluster->GetCellAmplitudeFraction(iDigit);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off
    
    if (IsRecalibrationOn()) {
      recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
    }
    
    eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
    
    energy += eCell;
    
  }//cell loop
  
  //Loop on cells
  for (Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++) 
  {
    //Get from the absid the supermodule, tower and eta/phi numbers
    geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta); 
    geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);        
    
    //Get the cell energy, if recalibration is on, apply factors
    fraction  = cluster->GetCellAmplitudeFraction(iDigit);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off
    
    if (!fCellsRecalibrated) {
      if (IsRecalibrationOn()) {
        recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
      }
    }
    
    eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
    
    // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2
    // C Side impair SM, nSupMod%2=1; A side pair SM, nSupMod%2=0
    if (shared && iSupMod%2) ieta+=AliEMCALGeoParams::fgkEMCALCols;
    
    if (cluster->E() > 0 && eCell > 0) {
      w  = GetCellWeight(eCell,cluster->E());
      
      etai=(Double_t)ieta;
      phii=(Double_t)iphi;  
      
      if (w > 0.0) {
        wtot += w ;
        nstat++;            
        //Shower shape
        sEta     += w * etai * etai ;
        etaMean  += w * etai ;
        sPhi     += w * phii * phii ;
        phiMean  += w * phii ; 
        sEtaPhi  += w * etai * phii ; 
      }
    } else
      AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, cluster->E()));
  }//cell loop
  
  //Normalize to the weight  
  if (wtot > 0) {
    etaMean /= wtot ;
    phiMean /= wtot ;
  } else
    AliError(Form("Wrong weight %f\n", wtot));
  
  //Calculate dispersion  
  for (Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++) 
  {
    //Get from the absid the supermodule, tower and eta/phi numbers
    geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta); 
    geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
    
    //Get the cell energy, if recalibration is on, apply factors
    fraction  = cluster->GetCellAmplitudeFraction(iDigit);
    if (fraction < 1e-4) fraction = 1.; // in case unfolding is off
    if (IsRecalibrationOn()) {
      recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
    }
    eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
    
    // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2
    // C Side impair SM, nSupMod%2=1; A side pair SM, nSupMod%2=0
    if (shared && iSupMod%2) ieta+=AliEMCALGeoParams::fgkEMCALCols;
    
    if (cluster->E() > 0 && eCell > 0) {
      w  = GetCellWeight(eCell,cluster->E());
      
      etai=(Double_t)ieta;
      phii=(Double_t)iphi;    
      if (w > 0.0) { 
        disp +=  w *((etai-etaMean)*(etai-etaMean)+(phii-phiMean)*(phii-phiMean)); 
        dEta +=  w * (etai-etaMean)*(etai-etaMean) ; 
        dPhi +=  w * (phii-phiMean)*(phii-phiMean) ; 
      }
    } else
      AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, cluster->E()));
  }// cell loop
  
  //Normalize to the weigth and set shower shape parameters
  if (wtot > 0 && nstat > 1) {
    disp    /= wtot ;
    dEta    /= wtot ;
    dPhi    /= wtot ;
    sEta    /= wtot ;
    sPhi    /= wtot ;
    sEtaPhi /= wtot ;
    
    sEta    -= etaMean * etaMean ;
    sPhi    -= phiMean * phiMean ;
    sEtaPhi -= etaMean * phiMean ;
    
    l0 = (0.5 * (sEta + sPhi) + TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
    l1 = (0.5 * (sEta + sPhi) - TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
  } else {
    l0   = 0. ;
    l1   = 0. ;
    dEta = 0. ; dPhi = 0. ; disp    = 0. ;
    sEta = 0. ; sPhi = 0. ; sEtaPhi = 0. ;
  }  
}

//____________________________________________________________________________________________
void AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, 
                                                                AliVCaloCells* cells, 
                                                                AliVCluster * cluster)
{
  // Calculates new center of gravity in the local EMCAL-module coordinates 
  // and tranfers into global ALICE coordinates
  // Calculates Dispersion and main axis and puts them into the cluster
  
  Float_t l0   = 0., l1   = 0.;
  Float_t disp = 0., dEta = 0., dPhi    = 0.; 
  Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
  
  AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(geom,cells,cluster,l0,l1,disp,
                                                             dEta, dPhi, sEta, sPhi, sEtaPhi);
  
  cluster->SetM02(l0);
  cluster->SetM20(l1);
  if (disp > 0. ) cluster->SetDispersion(TMath::Sqrt(disp)) ;
  
} 

//____________________________________________________________________________
void AliEMCALRecoUtils::FindMatches(AliVEvent *event,
                                    TObjArray * clusterArr,  
                                    const AliEMCALGeometry *geom)
{
  //This function should be called before the cluster loop
  //Before call this function, please recalculate the cluster positions
  //Given the input event, loop over all the tracks, select the closest cluster as matched with fCutR
  //Store matched cluster indexes and residuals
  
  fMatchedTrackIndex  ->Reset();
  fMatchedClusterIndex->Reset();
  fResidualPhi->Reset();
  fResidualEta->Reset();
  
  fMatchedTrackIndex  ->Set(1000);
  fMatchedClusterIndex->Set(1000);
  fResidualPhi->Set(1000);
  fResidualEta->Set(1000);
  
  AliESDEvent* esdevent = dynamic_cast<AliESDEvent*> (event);
  AliAODEvent* aodevent = dynamic_cast<AliAODEvent*> (event);
  
  // init the magnetic field if not already on
  if (!TGeoGlobalMagField::Instance()->GetField()) {
    if (!event->InitMagneticField())
    {
      AliInfo("Mag Field not initialized, null esd/aod evetn pointers");
    }
  } // Init mag field
  
  if (esdevent) {
    UInt_t mask1 = esdevent->GetESDRun()->GetDetectorsInDAQ();
    UInt_t mask2 = esdevent->GetESDRun()->GetDetectorsInReco();
    Bool_t desc1 = (mask1 >> 3) & 0x1;
    Bool_t desc2 = (mask2 >> 3) & 0x1;
    if (desc1==0 || desc2==0) { 
//       AliError(Form("TPC not in DAQ/RECO: %u (%u)/%u (%u)", 
//       mask1, esdevent->GetESDRun()->GetDetectorsInReco(),
//       mask2, esdevent->GetESDRun()->GetDetectorsInDAQ()));
      fITSTrackSA=kTRUE;
    }
  }

  TObjArray *clusterArray = 0x0;
  if (!clusterArr) {
    clusterArray = new TObjArray(event->GetNumberOfCaloClusters());
    for (Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++) 
    {
      AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
      if (geom && !IsGoodCluster(cluster,geom,(AliVCaloCells*)event->GetEMCALCells())) 
	continue;
      clusterArray->AddAt(cluster,icl);
    }
  }
  
  Int_t    matched=0;
  Double_t cv[21];
  for (Int_t i=0; i<21;i++) cv[i]=0;
  for (Int_t itr=0; itr<event->GetNumberOfTracks(); itr++)
  {
    AliExternalTrackParam *trackParam = 0;
    
    //If the input event is ESD, the starting point for extrapolation is TPCOut, if available, or TPCInner 
    AliESDtrack *esdTrack = 0;
    AliAODTrack *aodTrack = 0;
    if (esdevent) {
      esdTrack = esdevent->GetTrack(itr);
      if (!esdTrack) continue;
      if (!IsAccepted(esdTrack)) continue;
      if (esdTrack->Pt()<fCutMinTrackPt) continue;
      Double_t phi = esdTrack->Phi()*TMath::RadToDeg();
      if (TMath::Abs(esdTrack->Eta())>0.9 || phi <= 10 || phi >= 250 ) continue;
      if (!fITSTrackSA)
	trackParam =  const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());  // if TPC Available
      else
	trackParam =  new AliExternalTrackParam(*esdTrack); // If ITS Track Standing alone		
    }
    
    //If the input event is AOD, the starting point for extrapolation is at vertex
    //AOD tracks are selected according to its filterbit.
    else if (aodevent) {
      aodTrack = dynamic_cast<AliAODTrack*>(aodevent->GetTrack(itr));
      if(!aodTrack) AliFatal("Not a standard AOD");
      if (!aodTrack) continue;
            
      if (fAODTPCOnlyTracks) { // Match with TPC only tracks, default from May 2013, before filter bit 32
        //printf("Match with TPC only tracks, accept? %d, test bit 128 <%d> \n", aodTrack->IsTPCOnly(), aodTrack->TestFilterMask(128));
        if (!aodTrack->IsTPCConstrained()) continue ;
      } else if (fAODHybridTracks) { // Match with hybrid tracks
        //printf("Match with Hybrid tracks, accept? %d \n", aodTrack->IsHybridGlobalConstrainedGlobal());
        if (!aodTrack->IsHybridGlobalConstrainedGlobal()) continue ;
      } else { // Match with tracks on a mask
        //printf("Match with tracks having filter bit mask %d, accept? %d \n",fAODFilterMask,aodTrack->TestFilterMask(fAODFilterMask));
        if (!aodTrack->TestFilterMask(fAODFilterMask) ) continue; //Select AOD tracks
      }
      
      if (aodTrack->Pt()<fCutMinTrackPt) continue;

      Double_t phi = aodTrack->Phi()*TMath::RadToDeg();
      if (TMath::Abs(aodTrack->Eta())>0.9 || phi <= 10 || phi >= 250 ) 
	continue;
      Double_t pos[3],mom[3];
      aodTrack->GetXYZ(pos);
      aodTrack->GetPxPyPz(mom);
      AliDebug(5,Form("aod track: i=%d | pos=(%5.4f,%5.4f,%5.4f) | mom=(%5.4f,%5.4f,%5.4f) | charge=%d\n",itr,pos[0],pos[1],pos[2],mom[0],mom[1],mom[2],aodTrack->Charge()));

      trackParam= new AliExternalTrackParam(pos,mom,cv,aodTrack->Charge());
    }
    
    //Return if the input data is not "AOD" or "ESD"
    else {
      printf("Wrong input data type! Should be \"AOD\" or \"ESD\"\n");
      if (clusterArray) {
	clusterArray->Clear();
	delete clusterArray;
      }
      return;
    }
    
    if (!trackParam) continue;

    //Extrapolate the track to EMCal surface
    AliExternalTrackParam emcalParam(*trackParam);
    Float_t eta, phi, pt;
    if (!ExtrapolateTrackToEMCalSurface(&emcalParam, fEMCalSurfaceDistance, fMass, fStepSurface, eta, phi, pt)) {
      if (aodevent && trackParam) delete trackParam;
      if (fITSTrackSA && trackParam) delete trackParam;
      continue;
    }

    if (TMath::Abs(eta)>0.75 || (phi) < 70*TMath::DegToRad() || (phi) > 190*TMath::DegToRad()) {
      if (aodevent && trackParam) delete trackParam;
      if (fITSTrackSA && trackParam) delete trackParam;
      continue;
    }

    //Find matched clusters
    Int_t index = -1;
    Float_t dEta = -999, dPhi = -999;
    if (!clusterArr) {
      index = FindMatchedClusterInClusterArr(&emcalParam, &emcalParam, clusterArray, dEta, dPhi);  
    } else {
      index = FindMatchedClusterInClusterArr(&emcalParam, &emcalParam, clusterArr, dEta, dPhi);  
    }  
    
    if (index>-1) {
      fMatchedTrackIndex   ->AddAt(itr,matched);
      fMatchedClusterIndex ->AddAt(index,matched);
      fResidualEta         ->AddAt(dEta,matched);
      fResidualPhi         ->AddAt(dPhi,matched);
      matched++;
    }
    if (aodevent && trackParam) delete trackParam;
    if (fITSTrackSA && trackParam) delete trackParam;
  }//track loop

  if (clusterArray) {
    clusterArray->Clear();
    delete clusterArray;
  }
  
  AliDebug(2,Form("Number of matched pairs = %d !\n",matched));
  
  fMatchedTrackIndex   ->Set(matched);
  fMatchedClusterIndex ->Set(matched);
  fResidualPhi         ->Set(matched);
  fResidualEta         ->Set(matched);
}

//________________________________________________________________________________
Int_t AliEMCALRecoUtils::FindMatchedClusterInEvent(const AliESDtrack *track, 
                                                   const AliVEvent *event, 
                                                   const AliEMCALGeometry *geom, 
                                                   Float_t &dEta, Float_t &dPhi)
{
  //
  // This function returns the index of matched cluster to input track
  // Returns -1 if no match is found
  Int_t index = -1;
  Double_t phiV = track->Phi()*TMath::RadToDeg();
  if (TMath::Abs(track->Eta())>0.9 || phiV <= 10 || phiV >= 250 ) return index;
  AliExternalTrackParam *trackParam = 0;
  if (!fITSTrackSA)
    trackParam = const_cast<AliExternalTrackParam*>(track->GetInnerParam());  // If TPC
  else
    trackParam = new AliExternalTrackParam(*track);
    
  if (!trackParam) return index;
  AliExternalTrackParam emcalParam(*trackParam);
  Float_t eta, phi, pt;

  if (!ExtrapolateTrackToEMCalSurface(&emcalParam, fEMCalSurfaceDistance, fMass, fStepSurface, eta, phi, pt))	{
    if (fITSTrackSA) delete trackParam;
    return index;
  }
  if (TMath::Abs(eta)>0.75 || (phi) < 70*TMath::DegToRad() || (phi) > 190*TMath::DegToRad()) {
    if (fITSTrackSA) delete trackParam;
    return index;
  }
  
  TObjArray *clusterArr = new TObjArray(event->GetNumberOfCaloClusters());

  for (Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++)
  {
    AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
    if (geom && !IsGoodCluster(cluster,geom,(AliVCaloCells*)event->GetEMCALCells())) continue;
    clusterArr->AddAt(cluster,icl);
  }

  index = FindMatchedClusterInClusterArr(&emcalParam, &emcalParam, clusterArr, dEta, dPhi);  
  clusterArr->Clear();
  delete clusterArr;
  if (fITSTrackSA) delete trackParam;

  return index;
}

//_______________________________________________________________________________________________
Int_t  AliEMCALRecoUtils::FindMatchedClusterInClusterArr(const AliExternalTrackParam *emcalParam, 
                                                         AliExternalTrackParam *trkParam, 
                                                         const TObjArray * clusterArr, 
                                                         Float_t &dEta, Float_t &dPhi)
{
  // Find matched cluster in array
  
  dEta=-999, dPhi=-999;
  Float_t dRMax = fCutR, dEtaMax=fCutEta, dPhiMax=fCutPhi;
  Int_t index = -1;
  Float_t tmpEta=-999, tmpPhi=-999;

  Double_t exPos[3] = {0.,0.,0.};
  if (!emcalParam->GetXYZ(exPos)) return index;

  Float_t clsPos[3] = {0.,0.,0.};
  for (Int_t icl=0; icl<clusterArr->GetEntriesFast(); icl++)
  {
    AliVCluster *cluster = dynamic_cast<AliVCluster*> (clusterArr->At(icl)) ;
    if (!cluster || !cluster->IsEMCAL()) continue;
    cluster->GetPosition(clsPos);
    Double_t dR = TMath::Sqrt(TMath::Power(exPos[0]-clsPos[0],2)+TMath::Power(exPos[1]-clsPos[1],2)+TMath::Power(exPos[2]-clsPos[2],2));
    if (dR > fClusterWindow) continue;
    
    AliExternalTrackParam trkPamTmp (*trkParam);//Retrieve the starting point every time before the extrapolation
    if (!ExtrapolateTrackToCluster(&trkPamTmp, cluster, fMass, fStepCluster, tmpEta, tmpPhi)) continue;
    if (fCutEtaPhiSum) {
      Float_t tmpR=TMath::Sqrt(tmpEta*tmpEta + tmpPhi*tmpPhi);
      if (tmpR<dRMax) {
        dRMax=tmpR;
        dEtaMax=tmpEta;
        dPhiMax=tmpPhi;
        index=icl;
      }
    } else if (fCutEtaPhiSeparate) {
      if (TMath::Abs(tmpEta)<TMath::Abs(dEtaMax) && TMath::Abs(tmpPhi)<TMath::Abs(dPhiMax)) {
        dEtaMax = tmpEta;
        dPhiMax = tmpPhi;
        index=icl;
      }
    } else {
      printf("Error: please specify your cut criteria\n");
      printf("To cut on sqrt(dEta^2+dPhi^2), use: SwitchOnCutEtaPhiSum()\n");
      printf("To cut on dEta and dPhi separately, use: SwitchOnCutEtaPhiSeparate()\n");
      return index;
    }
  }

  dEta=dEtaMax;
  dPhi=dPhiMax;

  return index;
}

//------------------------------------------------------------------------------------
Bool_t AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(AliVTrack *track,
                                                         Double_t emcalR, Double_t mass,
                                                         Double_t step, Double_t minpt,
                                                         Bool_t useMassForTracking)
{ 
  // Extrapolate track to EMCAL surface

  track->SetTrackPhiEtaPtOnEMCal(-999, -999, -999);

  if (track->Pt()<minpt)
    return kFALSE;

  Double_t phi = track->Phi()*TMath::RadToDeg();
  if (TMath::Abs(track->Eta())>0.9 || phi <= 10 || phi >= 250) 
    return kFALSE;

  AliESDtrack *esdt = dynamic_cast<AliESDtrack*>(track);
  AliAODTrack *aodt = 0;
  if (!esdt) {
    aodt = dynamic_cast<AliAODTrack*>(track);
    if (!aodt)
      return kFALSE;
  }

  // Select the mass hypothesis
  if ( mass < 0 )
  {
    Bool_t onlyTPC = kFALSE;
    if ( mass == -99 ) onlyTPC=kTRUE;
    
    if (esdt)
    {
      if ( useMassForTracking ) mass = esdt->GetMassForTracking();
      else                      mass = esdt->GetMass(onlyTPC);
    }
    else
    {
      if ( useMassForTracking ) mass = aodt->GetMassForTracking();
      else                      mass = aodt->M();
    }
  }

  AliExternalTrackParam *trackParam = 0;
  if (esdt) {
    const AliExternalTrackParam *in = esdt->GetInnerParam();
    if (!in)
      return kFALSE;
    trackParam = new AliExternalTrackParam(*in);
  } else {
    Double_t xyz[3] = {0}, pxpypz[3] = {0}, cv[21] = {0};
    aodt->PxPyPz(pxpypz);  
    aodt->XvYvZv(xyz);
    aodt->GetCovarianceXYZPxPyPz(cv);  
    trackParam = new AliExternalTrackParam(xyz,pxpypz,cv,aodt->Charge());
  }
  if (!trackParam)
    return kFALSE;

  Float_t etaout=-999, phiout=-999, ptout=-999;
  Bool_t ret = ExtrapolateTrackToEMCalSurface(trackParam, 
					      emcalR,
					      mass,
					      step,
					      etaout, 
					      phiout,
					      ptout);
  delete trackParam;
  if (!ret)
    return kFALSE;
  if (TMath::Abs(etaout)>0.75 || (phiout<70*TMath::DegToRad()) || (phiout>190*TMath::DegToRad()))
    return kFALSE;
  track->SetTrackPhiEtaPtOnEMCal(phiout, etaout, ptout);
  return kTRUE;
}


//------------------------------------------------------------------------------------
Bool_t AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(AliExternalTrackParam *trkParam, 
                                                         Double_t emcalR,
                                                         Double_t mass, 
                                                         Double_t step, 
                                                         Float_t &eta, 
                                                         Float_t &phi,
							 Float_t &pt)
{
  //Extrapolate track to EMCAL surface
  
  eta = -999, phi = -999, pt = -999;
  if (!trkParam) return kFALSE;
  if (!AliTrackerBase::PropagateTrackToBxByBz(trkParam, emcalR, mass, step, kTRUE, 0.8, -1)) return kFALSE;
  Double_t trkPos[3] = {0.,0.,0.};
  if (!trkParam->GetXYZ(trkPos)) return kFALSE;
  TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
  eta = trkPosVec.Eta();
  phi = trkPosVec.Phi();
  pt = trkParam->Pt();
  if (phi<0)
    phi += 2*TMath::Pi();

  return kTRUE;
}

//-----------------------------------------------------------------------------------
Bool_t AliEMCALRecoUtils::ExtrapolateTrackToPosition(AliExternalTrackParam *trkParam, 
                                                     const Float_t *clsPos, 
                                                     Double_t mass, 
                                                     Double_t step, 
                                                     Float_t &tmpEta, 
                                                     Float_t &tmpPhi)
{
  //
  //Return the residual by extrapolating a track param to a global position
  //
  tmpEta = -999;
  tmpPhi = -999;
  if (!trkParam) return kFALSE;
  Double_t trkPos[3] = {0.,0.,0.};
  TVector3 vec(clsPos[0],clsPos[1],clsPos[2]);
  Double_t alpha =  ((int)(vec.Phi()*TMath::RadToDeg()/20)+0.5)*20*TMath::DegToRad();
  vec.RotateZ(-alpha); //Rotate the cluster to the local extrapolation coordinate system
  if (!AliTrackerBase::PropagateTrackToBxByBz(trkParam, vec.X(), mass, step,kTRUE, 0.8, -1)) return kFALSE;
  if (!trkParam->GetXYZ(trkPos)) return kFALSE; //Get the extrapolated global position

  TVector3 clsPosVec(clsPos[0],clsPos[1],clsPos[2]);
  TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);

  // track cluster matching
  tmpPhi = clsPosVec.DeltaPhi(trkPosVec);    // tmpPhi is between -pi and pi
  tmpEta = clsPosVec.Eta()-trkPosVec.Eta();

  return kTRUE;
}

//----------------------------------------------------------------------------------
Bool_t AliEMCALRecoUtils::ExtrapolateTrackToCluster(AliExternalTrackParam *trkParam, 
                                                    const AliVCluster *cluster, 
                                                    Double_t mass, 
                                                    Double_t step, 
                                                    Float_t &tmpEta, 
                                                    Float_t &tmpPhi)
{
  //
  //Return the residual by extrapolating a track param to a cluster
  //
  tmpEta = -999;
  tmpPhi = -999;
  if (!cluster || !trkParam) 
    return kFALSE;

  Float_t clsPos[3] = {0.,0.,0.};
  cluster->GetPosition(clsPos);

  return ExtrapolateTrackToPosition(trkParam, clsPos, mass, step, tmpEta, tmpPhi);
}

//---------------------------------------------------------------------------------
Bool_t AliEMCALRecoUtils::ExtrapolateTrackToCluster(AliExternalTrackParam *trkParam, 
                                                    const AliVCluster *cluster, 
                                                    Float_t &tmpEta, 
                                                    Float_t &tmpPhi)
{
  //
  //Return the residual by extrapolating a track param to a clusterfStepCluster
  //

  return ExtrapolateTrackToCluster(trkParam, cluster, fMass, fStepCluster, tmpEta, tmpPhi);
}

//_______________________________________________________________________
void AliEMCALRecoUtils::GetMatchedResiduals(Int_t clsIndex, 
                                            Float_t &dEta, Float_t &dPhi)
{
  //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex)
  //Get the residuals dEta and dPhi for this cluster to the closest track
  //Works with ESDs and AODs

  if (FindMatchedPosForCluster(clsIndex) >= 999) {
    AliDebug(2,"No matched tracks found!\n");
    dEta=999.;
    dPhi=999.;
    return;
  }
  dEta = fResidualEta->At(FindMatchedPosForCluster(clsIndex));
  dPhi = fResidualPhi->At(FindMatchedPosForCluster(clsIndex));
}

//______________________________________________________________________________________________
void AliEMCALRecoUtils::GetMatchedClusterResiduals(Int_t trkIndex, Float_t &dEta, Float_t &dPhi)
{
  //Given a track index as in AliESDEvent::GetTrack(trkIndex)
  //Get the residuals dEta and dPhi for this track to the closest cluster
  //Works with ESDs and AODs

  if (FindMatchedPosForTrack(trkIndex) >= 999) {
    AliDebug(2,"No matched cluster found!\n");
    dEta=999.;
    dPhi=999.;
    return;
  }
  dEta = fResidualEta->At(FindMatchedPosForTrack(trkIndex));
  dPhi = fResidualPhi->At(FindMatchedPosForTrack(trkIndex));
}

//__________________________________________________________
Int_t AliEMCALRecoUtils::GetMatchedTrackIndex(Int_t clsIndex)
{
  //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex)
  //Get the index of matched track to this cluster
  //Works with ESDs and AODs
  
  if (IsClusterMatched(clsIndex))
    return fMatchedTrackIndex->At(FindMatchedPosForCluster(clsIndex));
  else 
    return -1; 
}

//__________________________________________________________
Int_t AliEMCALRecoUtils::GetMatchedClusterIndex(Int_t trkIndex)
{
  //Given a track index as in AliESDEvent::GetTrack(trkIndex)
  //Get the index of matched cluster to this track
  //Works with ESDs and AODs
  
  if (IsTrackMatched(trkIndex))
    return fMatchedClusterIndex->At(FindMatchedPosForTrack(trkIndex));
  else 
    return -1; 
}

//______________________________________________________________
Bool_t AliEMCALRecoUtils::IsClusterMatched(Int_t clsIndex) const
{
  //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex)
  //Returns if the cluster has a match
  if (FindMatchedPosForCluster(clsIndex) < 999) 
    return kTRUE;
  else
    return kFALSE;
}

//____________________________________________________________
Bool_t AliEMCALRecoUtils::IsTrackMatched(Int_t trkIndex) const 
{
  //Given a track index as in AliESDEvent::GetTrack(trkIndex)
  //Returns if the track has a match
  if (FindMatchedPosForTrack(trkIndex) < 999) 
    return kTRUE;
  else
    return kFALSE;
}

//______________________________________________________________________
UInt_t AliEMCALRecoUtils::FindMatchedPosForCluster(Int_t clsIndex) const
{
  //Given a cluster index as in AliESDEvent::GetCaloCluster(clsIndex)
  //Returns the position of the match in the fMatchedClusterIndex array
  Float_t tmpR = fCutR;
  UInt_t pos = 999;
  
  for (Int_t i=0; i<fMatchedClusterIndex->GetSize(); i++) 
  {
    if (fMatchedClusterIndex->At(i)==clsIndex) {
      Float_t r = TMath::Sqrt(fResidualEta->At(i)*fResidualEta->At(i) + fResidualPhi->At(i)*fResidualPhi->At(i));
      if (r<tmpR) {
        pos=i;
        tmpR=r;
        AliDebug(3,Form("Matched cluster index: index: %d, dEta: %2.4f, dPhi: %2.4f.\n",
                        fMatchedClusterIndex->At(i),fResidualEta->At(i),fResidualPhi->At(i)));
      }
    }
  }
  return pos;
}

//____________________________________________________________________
UInt_t AliEMCALRecoUtils::FindMatchedPosForTrack(Int_t trkIndex) const
{
  //Given a track index as in AliESDEvent::GetTrack(trkIndex)
  //Returns the position of the match in the fMatchedTrackIndex array
  Float_t tmpR = fCutR;
  UInt_t pos = 999;
  
  for (Int_t i=0; i<fMatchedTrackIndex->GetSize(); i++) 
  {
    if (fMatchedTrackIndex->At(i)==trkIndex) {
      Float_t r = TMath::Sqrt(fResidualEta->At(i)*fResidualEta->At(i) + fResidualPhi->At(i)*fResidualPhi->At(i));
      if (r<tmpR) {
        pos=i;
        tmpR=r;
        AliDebug(3,Form("Matched track index: index: %d, dEta: %2.4f, dPhi: %2.4f.\n",
                        fMatchedTrackIndex->At(i),fResidualEta->At(i),fResidualPhi->At(i)));
      }
    }
  }
  return pos;
}

//__________________________________________________________________________
Bool_t AliEMCALRecoUtils::IsGoodCluster(AliVCluster *cluster, 
                                        const AliEMCALGeometry *geom, 
                                        AliVCaloCells* cells, Int_t bc)
{
  // check if the cluster survives some quality cut
  //
  //
  Bool_t isGood=kTRUE;

  if (!cluster || !cluster->IsEMCAL())              return kFALSE;
  if (ClusterContainsBadChannel(geom,cluster->GetCellsAbsId(),cluster->GetNCells())) return kFALSE;
  if (!CheckCellFiducialRegion(geom,cluster,cells)) return kFALSE;
  if (IsExoticCluster(cluster, cells,bc))           return kFALSE;

  return isGood;
}

//__________________________________________________________
Bool_t AliEMCALRecoUtils::IsAccepted(AliESDtrack *esdTrack)
{
  // Given a esd track, return whether the track survive all the cuts

  // The different quality parameter are first
  // retrieved from the track. then it is found out what cuts the
  // track did not survive and finally the cuts are imposed.

  UInt_t status = esdTrack->GetStatus();

  Int_t nClustersITS = esdTrack->GetITSclusters(0);
  Int_t nClustersTPC = esdTrack->GetTPCclusters(0);

  Float_t chi2PerClusterITS = -1;
  Float_t chi2PerClusterTPC = -1;
  if (nClustersITS!=0)
    chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
  if (nClustersTPC!=0) 
    chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);


  //DCA cuts
  if (fTrackCutsType==kGlobalCut) {
    Float_t maxDCAToVertexXYPtDep = 0.0182 + 0.0350/TMath::Power(esdTrack->Pt(),1.01); //This expression comes from AliESDtrackCuts::GetStandardITSTPCTrackCuts2010()
    //AliDebug(3,Form("Track pT = %f, DCAtoVertexXY = %f",esdTrack->Pt(),MaxDCAToVertexXYPtDep));
    SetMaxDCAToVertexXY(maxDCAToVertexXYPtDep); //Set pT dependent DCA cut to vertex in x-y plane
  }

  Float_t b[2];
  Float_t bCov[3];
  esdTrack->GetImpactParameters(b,bCov);
  if (bCov[0]<=0 || bCov[2]<=0) {
    AliDebug(1, "Estimated b resolution lower or equal zero!");
    bCov[0]=0; bCov[2]=0;
  }

  Float_t dcaToVertexXY = b[0];
  Float_t dcaToVertexZ = b[1];
  Float_t dcaToVertex = -1;

  if (fCutDCAToVertex2D)
    dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
  else
    dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
    
  // cut the track?
  
  Bool_t cuts[kNCuts];
  for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
  
  // track quality cuts
  if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
    cuts[0]=kTRUE;
  if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
    cuts[1]=kTRUE;
  if (nClustersTPC<fCutMinNClusterTPC)
    cuts[2]=kTRUE;
  if (nClustersITS<fCutMinNClusterITS) 
    cuts[3]=kTRUE;
  if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC) 
    cuts[4]=kTRUE; 
  if (chi2PerClusterITS>fCutMaxChi2PerClusterITS) 
    cuts[5]=kTRUE;  
  if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
    cuts[6]=kTRUE;
  if (fCutDCAToVertex2D && dcaToVertex > 1)
    cuts[7] = kTRUE;
  if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
    cuts[8] = kTRUE;
  if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
    cuts[9] = kTRUE;

  if (fTrackCutsType==kGlobalCut) {
    //Require at least one SPD point + anything else in ITS
    if ( (esdTrack->HasPointOnITSLayer(0) || esdTrack->HasPointOnITSLayer(1)) == kFALSE)
      cuts[10] = kTRUE;
  }

  // ITS
  if (fCutRequireITSStandAlone || fCutRequireITSpureSA) {
    if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)) {
      // TPC tracks
      cuts[11] = kTRUE; 
    } else {
      // ITS standalone tracks
      if (fCutRequireITSStandAlone && !fCutRequireITSpureSA) {
	if (status & AliESDtrack::kITSpureSA) cuts[11] = kTRUE;
      } else if (fCutRequireITSpureSA) {
	if (!(status & AliESDtrack::kITSpureSA)) cuts[11] = kTRUE;
      }
    }
  }
  
  Bool_t cut=kFALSE;
  for (Int_t i=0; i<kNCuts; i++)
    if (cuts[i]) { cut = kTRUE ; }

    // cut the track
  if (cut) 
    return kFALSE;
  else 
    return kTRUE;
}

//_____________________________________
void AliEMCALRecoUtils::InitTrackCuts()
{
  //Intilize the track cut criteria
  //By default these cuts are set according to AliESDtrackCuts::GetStandardTPCOnlyTrackCuts()
  //Also you can customize the cuts using the setters
  
  switch (fTrackCutsType)
  {
    case kTPCOnlyCut:
    {
      AliInfo(Form("Track cuts for matching: GetStandardTPCOnlyTrackCuts()"));
      //TPC
      SetMinNClustersTPC(70);
      SetMaxChi2PerClusterTPC(4);
      SetAcceptKinkDaughters(kFALSE);
      SetRequireTPCRefit(kFALSE);
      
      //ITS
      SetRequireITSRefit(kFALSE);
      SetMaxDCAToVertexZ(3.2);
      SetMaxDCAToVertexXY(2.4);
      SetDCAToVertex2D(kTRUE);
      
      break;
    }
      
    case kGlobalCut:
    {
      AliInfo(Form("Track cuts for matching: GetStandardITSTPCTrackCuts2010(kTURE)"));
      //TPC
      SetMinNClustersTPC(70);
      SetMaxChi2PerClusterTPC(4);
      SetAcceptKinkDaughters(kFALSE);
      SetRequireTPCRefit(kTRUE);
      
      //ITS
      SetRequireITSRefit(kTRUE);
      SetMaxDCAToVertexZ(2);
      SetMaxDCAToVertexXY();
      SetDCAToVertex2D(kFALSE);
      
      break;
    }
      
    case kLooseCut:
    {
      AliInfo(Form("Track cuts for matching: Loose cut w/o DCA cut"));
      SetMinNClustersTPC(50);
      SetAcceptKinkDaughters(kTRUE);
      
      break;
    }

    case kITSStandAlone:
    {
      AliInfo(Form("Track cuts for matching: ITS Stand Alone tracks cut w/o DCA cut"));
      SetRequireITSRefit(kTRUE);
      SetRequireITSStandAlone(kTRUE);
      SetITSTrackSA(kTRUE);
      break;
    }
    
  }
}


//________________________________________________________________________
void AliEMCALRecoUtils::SetClusterMatchedToTrack(const AliVEvent *event)
{
  // Checks if tracks are matched to EMC clusters and set the matched EMCAL cluster index to ESD track. 

  Int_t nTracks = event->GetNumberOfTracks();
  for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) 
  {
    AliVTrack* track = dynamic_cast<AliVTrack*>(event->GetTrack(iTrack));
    if (!track) 
    {
      AliWarning(Form("Could not receive track %d", iTrack));
      continue;
    }
    
    Int_t matchClusIndex = GetMatchedClusterIndex(iTrack);       
    track->SetEMCALcluster(matchClusIndex); //sets -1 if track not matched within residual
    /*the following can be done better if AliVTrack::SetStatus will be there. Patch pending with Andreas/Peter*/
    AliESDtrack* esdtrack = dynamic_cast<AliESDtrack*>(track);
    if (esdtrack) { 
      if (matchClusIndex != -1) 
        esdtrack->SetStatus(AliESDtrack::kEMCALmatch);
      else
        esdtrack->ResetStatus(AliESDtrack::kEMCALmatch);
    } else {
      AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(track);
      if (matchClusIndex != -1) 
        aodtrack->SetStatus(AliESDtrack::kEMCALmatch);
      else
        aodtrack->ResetStatus(AliESDtrack::kEMCALmatch);
    }
  }
  AliDebug(2,"Track matched to closest cluster");  
}

//_________________________________________________________________________
void AliEMCALRecoUtils::SetTracksMatchedToCluster(const AliVEvent *event)
{
  // Checks if EMC clusters are matched to ESD track.
  // Adds track indexes of all the tracks matched to a cluster withing residuals in ESDCalocluster.
  
  for (Int_t iClus=0; iClus < event->GetNumberOfCaloClusters(); ++iClus) 
  {
    AliVCluster *cluster = event->GetCaloCluster(iClus);
    if (!cluster->IsEMCAL()) 
      continue;
    
    Int_t nTracks = event->GetNumberOfTracks();
    TArrayI arrayTrackMatched(nTracks);
    
    // Get the closest track matched to the cluster
    Int_t nMatched = 0;
    Int_t matchTrackIndex = GetMatchedTrackIndex(iClus);
    if (matchTrackIndex != -1) 
    {
      arrayTrackMatched[nMatched] = matchTrackIndex;
      nMatched++;
    }
    
    // Get all other tracks matched to the cluster
    for (Int_t iTrk=0; iTrk<nTracks; ++iTrk) 
    {
      AliVTrack* track = dynamic_cast<AliVTrack*>(event->GetTrack(iTrk));
      
      if( !track ) continue;
      
      if ( iTrk == matchTrackIndex ) continue;
      
      if ( track->GetEMCALcluster() == iClus )
      {
        arrayTrackMatched[nMatched] = iTrk;
        ++nMatched;
      }
    }
    
    //printf("Tender::SetTracksMatchedToCluster - cluster E %f, N matches %d, first match %d\n",cluster->E(),nMatched,arrayTrackMatched[0]);
    
    arrayTrackMatched.Set(nMatched);
    AliESDCaloCluster *esdcluster = dynamic_cast<AliESDCaloCluster*>(cluster);
    if (esdcluster) 
      esdcluster->AddTracksMatched(arrayTrackMatched);
    else if (nMatched>0) {
      AliAODCaloCluster *aodcluster = dynamic_cast<AliAODCaloCluster*>(cluster);
      if (aodcluster)
        aodcluster->AddTrackMatched(event->GetTrack(arrayTrackMatched.At(0)));
    }
    
    Float_t eta= -999, phi = -999;
    if (matchTrackIndex != -1) 
      GetMatchedResiduals(iClus, eta, phi);
    cluster->SetTrackDistance(phi, eta);
  }
  
  AliDebug(2,"Cluster matched to tracks");  
}

//___________________________________________________
void AliEMCALRecoUtils::Print(const Option_t *) const 
{
  // Print Parameters
  
  printf("AliEMCALRecoUtils Settings: \n");
  printf("Misalignment shifts\n");
  for (Int_t i=0; i<5; i++) printf("\t sector %d, traslation (x,y,z)=(%f,%f,%f), rotation (x,y,z)=(%f,%f,%f)\n",i, 
                                  fMisalTransShift[i*3],fMisalTransShift[i*3+1],fMisalTransShift[i*3+2],
                                  fMisalRotShift[i*3],  fMisalRotShift[i*3+1],  fMisalRotShift[i*3+2]   );
  printf("Non linearity function %d, parameters:\n", fNonLinearityFunction);
  for (Int_t i=0; i<6; i++) printf("param[%d]=%f\n",i, fNonLinearityParams[i]);
  
  printf("Position Recalculation option %d, Particle Type %d, fW0 %2.2f, Recalibrate Data %d \n",fPosAlgo,fParticleType,fW0, fRecalibration);

  printf("Matching criteria: ");
  if (fCutEtaPhiSum) {
    printf("sqrt(dEta^2+dPhi^2)<%4.3f\n",fCutR);
  } else if (fCutEtaPhiSeparate) {
    printf("dEta<%4.3f, dPhi<%4.3f\n",fCutEta,fCutPhi);
  } else {
    printf("Error\n");
    printf("please specify your cut criteria\n");
    printf("To cut on sqrt(dEta^2+dPhi^2), use: SwitchOnCutEtaPhiSum()\n");
    printf("To cut on dEta and dPhi separately, use: SwitchOnCutEtaPhiSeparate()\n");
  }

  printf("Mass hypothesis = %2.3f [GeV/c^2], extrapolation step to surface = %2.2f[cm], step to cluster = %2.2f[cm]\n",fMass,fStepSurface, fStepCluster);
  printf("Cluster selection window: dR < %2.0f\n",fClusterWindow);

  printf("Track cuts: \n");
  printf("Minimum track pT: %1.2f\n",fCutMinTrackPt);
  printf("AOD track selection: tpc only %d, or hybrid %d, or mask: %d\n",fAODTPCOnlyTracks,fAODHybridTracks, fAODFilterMask);
  printf("TPCRefit = %d, ITSRefit = %d\n",fCutRequireTPCRefit,fCutRequireITSRefit);
  printf("AcceptKinks = %d\n",fCutAcceptKinkDaughters);
  printf("MinNCulsterTPC = %d, MinNClusterITS = %d\n",fCutMinNClusterTPC,fCutMinNClusterITS);
  printf("MaxChi2TPC = %2.2f, MaxChi2ITS = %2.2f\n",fCutMaxChi2PerClusterTPC,fCutMaxChi2PerClusterITS);
  printf("DCSToVertex2D = %d, MaxDCAToVertexXY = %2.2f, MaxDCAToVertexZ = %2.2f\n",fCutDCAToVertex2D,fCutMaxDCAToVertexXY,fCutMaxDCAToVertexZ);
}
 AliEMCALRecoUtils.cxx:1
 AliEMCALRecoUtils.cxx:2
 AliEMCALRecoUtils.cxx:3
 AliEMCALRecoUtils.cxx:4
 AliEMCALRecoUtils.cxx:5
 AliEMCALRecoUtils.cxx:6
 AliEMCALRecoUtils.cxx:7
 AliEMCALRecoUtils.cxx:8
 AliEMCALRecoUtils.cxx:9
 AliEMCALRecoUtils.cxx:10
 AliEMCALRecoUtils.cxx:11
 AliEMCALRecoUtils.cxx:12
 AliEMCALRecoUtils.cxx:13
 AliEMCALRecoUtils.cxx:14
 AliEMCALRecoUtils.cxx:15
 AliEMCALRecoUtils.cxx:16
 AliEMCALRecoUtils.cxx:17
 AliEMCALRecoUtils.cxx:18
 AliEMCALRecoUtils.cxx:19
 AliEMCALRecoUtils.cxx:20
 AliEMCALRecoUtils.cxx:21
 AliEMCALRecoUtils.cxx:22
 AliEMCALRecoUtils.cxx:23
 AliEMCALRecoUtils.cxx:24
 AliEMCALRecoUtils.cxx:25
 AliEMCALRecoUtils.cxx:26
 AliEMCALRecoUtils.cxx:27
 AliEMCALRecoUtils.cxx:28
 AliEMCALRecoUtils.cxx:29
 AliEMCALRecoUtils.cxx:30
 AliEMCALRecoUtils.cxx:31
 AliEMCALRecoUtils.cxx:32
 AliEMCALRecoUtils.cxx:33
 AliEMCALRecoUtils.cxx:34
 AliEMCALRecoUtils.cxx:35
 AliEMCALRecoUtils.cxx:36
 AliEMCALRecoUtils.cxx:37
 AliEMCALRecoUtils.cxx:38
 AliEMCALRecoUtils.cxx:39
 AliEMCALRecoUtils.cxx:40
 AliEMCALRecoUtils.cxx:41
 AliEMCALRecoUtils.cxx:42
 AliEMCALRecoUtils.cxx:43
 AliEMCALRecoUtils.cxx:44
 AliEMCALRecoUtils.cxx:45
 AliEMCALRecoUtils.cxx:46
 AliEMCALRecoUtils.cxx:47
 AliEMCALRecoUtils.cxx:48
 AliEMCALRecoUtils.cxx:49
 AliEMCALRecoUtils.cxx:50
 AliEMCALRecoUtils.cxx:51
 AliEMCALRecoUtils.cxx:52
 AliEMCALRecoUtils.cxx:53
 AliEMCALRecoUtils.cxx:54
 AliEMCALRecoUtils.cxx:55
 AliEMCALRecoUtils.cxx:56
 AliEMCALRecoUtils.cxx:57
 AliEMCALRecoUtils.cxx:58
 AliEMCALRecoUtils.cxx:59
 AliEMCALRecoUtils.cxx:60
 AliEMCALRecoUtils.cxx:61
 AliEMCALRecoUtils.cxx:62
 AliEMCALRecoUtils.cxx:63
 AliEMCALRecoUtils.cxx:64
 AliEMCALRecoUtils.cxx:65
 AliEMCALRecoUtils.cxx:66
 AliEMCALRecoUtils.cxx:67
 AliEMCALRecoUtils.cxx:68
 AliEMCALRecoUtils.cxx:69
 AliEMCALRecoUtils.cxx:70
 AliEMCALRecoUtils.cxx:71
 AliEMCALRecoUtils.cxx:72
 AliEMCALRecoUtils.cxx:73
 AliEMCALRecoUtils.cxx:74
 AliEMCALRecoUtils.cxx:75
 AliEMCALRecoUtils.cxx:76
 AliEMCALRecoUtils.cxx:77
 AliEMCALRecoUtils.cxx:78
 AliEMCALRecoUtils.cxx:79
 AliEMCALRecoUtils.cxx:80
 AliEMCALRecoUtils.cxx:81
 AliEMCALRecoUtils.cxx:82
 AliEMCALRecoUtils.cxx:83
 AliEMCALRecoUtils.cxx:84
 AliEMCALRecoUtils.cxx:85
 AliEMCALRecoUtils.cxx:86
 AliEMCALRecoUtils.cxx:87
 AliEMCALRecoUtils.cxx:88
 AliEMCALRecoUtils.cxx:89
 AliEMCALRecoUtils.cxx:90
 AliEMCALRecoUtils.cxx:91
 AliEMCALRecoUtils.cxx:92
 AliEMCALRecoUtils.cxx:93
 AliEMCALRecoUtils.cxx:94
 AliEMCALRecoUtils.cxx:95
 AliEMCALRecoUtils.cxx:96
 AliEMCALRecoUtils.cxx:97
 AliEMCALRecoUtils.cxx:98
 AliEMCALRecoUtils.cxx:99
 AliEMCALRecoUtils.cxx:100
 AliEMCALRecoUtils.cxx:101
 AliEMCALRecoUtils.cxx:102
 AliEMCALRecoUtils.cxx:103
 AliEMCALRecoUtils.cxx:104
 AliEMCALRecoUtils.cxx:105
 AliEMCALRecoUtils.cxx:106
 AliEMCALRecoUtils.cxx:107
 AliEMCALRecoUtils.cxx:108
 AliEMCALRecoUtils.cxx:109
 AliEMCALRecoUtils.cxx:110
 AliEMCALRecoUtils.cxx:111
 AliEMCALRecoUtils.cxx:112
 AliEMCALRecoUtils.cxx:113
 AliEMCALRecoUtils.cxx:114
 AliEMCALRecoUtils.cxx:115
 AliEMCALRecoUtils.cxx:116
 AliEMCALRecoUtils.cxx:117
 AliEMCALRecoUtils.cxx:118
 AliEMCALRecoUtils.cxx:119
 AliEMCALRecoUtils.cxx:120
 AliEMCALRecoUtils.cxx:121
 AliEMCALRecoUtils.cxx:122
 AliEMCALRecoUtils.cxx:123
 AliEMCALRecoUtils.cxx:124
 AliEMCALRecoUtils.cxx:125
 AliEMCALRecoUtils.cxx:126
 AliEMCALRecoUtils.cxx:127
 AliEMCALRecoUtils.cxx:128
 AliEMCALRecoUtils.cxx:129
 AliEMCALRecoUtils.cxx:130
 AliEMCALRecoUtils.cxx:131
 AliEMCALRecoUtils.cxx:132
 AliEMCALRecoUtils.cxx:133
 AliEMCALRecoUtils.cxx:134
 AliEMCALRecoUtils.cxx:135
 AliEMCALRecoUtils.cxx:136
 AliEMCALRecoUtils.cxx:137
 AliEMCALRecoUtils.cxx:138
 AliEMCALRecoUtils.cxx:139
 AliEMCALRecoUtils.cxx:140
 AliEMCALRecoUtils.cxx:141
 AliEMCALRecoUtils.cxx:142
 AliEMCALRecoUtils.cxx:143
 AliEMCALRecoUtils.cxx:144
 AliEMCALRecoUtils.cxx:145
 AliEMCALRecoUtils.cxx:146
 AliEMCALRecoUtils.cxx:147
 AliEMCALRecoUtils.cxx:148
 AliEMCALRecoUtils.cxx:149
 AliEMCALRecoUtils.cxx:150
 AliEMCALRecoUtils.cxx:151
 AliEMCALRecoUtils.cxx:152
 AliEMCALRecoUtils.cxx:153
 AliEMCALRecoUtils.cxx:154
 AliEMCALRecoUtils.cxx:155
 AliEMCALRecoUtils.cxx:156
 AliEMCALRecoUtils.cxx:157
 AliEMCALRecoUtils.cxx:158
 AliEMCALRecoUtils.cxx:159
 AliEMCALRecoUtils.cxx:160
 AliEMCALRecoUtils.cxx:161
 AliEMCALRecoUtils.cxx:162
 AliEMCALRecoUtils.cxx:163
 AliEMCALRecoUtils.cxx:164
 AliEMCALRecoUtils.cxx:165
 AliEMCALRecoUtils.cxx:166
 AliEMCALRecoUtils.cxx:167
 AliEMCALRecoUtils.cxx:168
 AliEMCALRecoUtils.cxx:169
 AliEMCALRecoUtils.cxx:170
 AliEMCALRecoUtils.cxx:171
 AliEMCALRecoUtils.cxx:172
 AliEMCALRecoUtils.cxx:173
 AliEMCALRecoUtils.cxx:174
 AliEMCALRecoUtils.cxx:175
 AliEMCALRecoUtils.cxx:176
 AliEMCALRecoUtils.cxx:177
 AliEMCALRecoUtils.cxx:178
 AliEMCALRecoUtils.cxx:179
 AliEMCALRecoUtils.cxx:180
 AliEMCALRecoUtils.cxx:181
 AliEMCALRecoUtils.cxx:182
 AliEMCALRecoUtils.cxx:183
 AliEMCALRecoUtils.cxx:184
 AliEMCALRecoUtils.cxx:185
 AliEMCALRecoUtils.cxx:186
 AliEMCALRecoUtils.cxx:187
 AliEMCALRecoUtils.cxx:188
 AliEMCALRecoUtils.cxx:189
 AliEMCALRecoUtils.cxx:190
 AliEMCALRecoUtils.cxx:191
 AliEMCALRecoUtils.cxx:192
 AliEMCALRecoUtils.cxx:193
 AliEMCALRecoUtils.cxx:194
 AliEMCALRecoUtils.cxx:195
 AliEMCALRecoUtils.cxx:196
 AliEMCALRecoUtils.cxx:197
 AliEMCALRecoUtils.cxx:198
 AliEMCALRecoUtils.cxx:199
 AliEMCALRecoUtils.cxx:200
 AliEMCALRecoUtils.cxx:201
 AliEMCALRecoUtils.cxx:202
 AliEMCALRecoUtils.cxx:203
 AliEMCALRecoUtils.cxx:204
 AliEMCALRecoUtils.cxx:205
 AliEMCALRecoUtils.cxx:206
 AliEMCALRecoUtils.cxx:207
 AliEMCALRecoUtils.cxx:208
 AliEMCALRecoUtils.cxx:209
 AliEMCALRecoUtils.cxx:210
 AliEMCALRecoUtils.cxx:211
 AliEMCALRecoUtils.cxx:212
 AliEMCALRecoUtils.cxx:213
 AliEMCALRecoUtils.cxx:214
 AliEMCALRecoUtils.cxx:215
 AliEMCALRecoUtils.cxx:216
 AliEMCALRecoUtils.cxx:217
 AliEMCALRecoUtils.cxx:218
 AliEMCALRecoUtils.cxx:219
 AliEMCALRecoUtils.cxx:220
 AliEMCALRecoUtils.cxx:221
 AliEMCALRecoUtils.cxx:222
 AliEMCALRecoUtils.cxx:223
 AliEMCALRecoUtils.cxx:224
 AliEMCALRecoUtils.cxx:225
 AliEMCALRecoUtils.cxx:226
 AliEMCALRecoUtils.cxx:227
 AliEMCALRecoUtils.cxx:228
 AliEMCALRecoUtils.cxx:229
 AliEMCALRecoUtils.cxx:230
 AliEMCALRecoUtils.cxx:231
 AliEMCALRecoUtils.cxx:232
 AliEMCALRecoUtils.cxx:233
 AliEMCALRecoUtils.cxx:234
 AliEMCALRecoUtils.cxx:235
 AliEMCALRecoUtils.cxx:236
 AliEMCALRecoUtils.cxx:237
 AliEMCALRecoUtils.cxx:238
 AliEMCALRecoUtils.cxx:239
 AliEMCALRecoUtils.cxx:240
 AliEMCALRecoUtils.cxx:241
 AliEMCALRecoUtils.cxx:242
 AliEMCALRecoUtils.cxx:243
 AliEMCALRecoUtils.cxx:244
 AliEMCALRecoUtils.cxx:245
 AliEMCALRecoUtils.cxx:246
 AliEMCALRecoUtils.cxx:247
 AliEMCALRecoUtils.cxx:248
 AliEMCALRecoUtils.cxx:249
 AliEMCALRecoUtils.cxx:250
 AliEMCALRecoUtils.cxx:251
 AliEMCALRecoUtils.cxx:252
 AliEMCALRecoUtils.cxx:253
 AliEMCALRecoUtils.cxx:254
 AliEMCALRecoUtils.cxx:255
 AliEMCALRecoUtils.cxx:256
 AliEMCALRecoUtils.cxx:257
 AliEMCALRecoUtils.cxx:258
 AliEMCALRecoUtils.cxx:259
 AliEMCALRecoUtils.cxx:260
 AliEMCALRecoUtils.cxx:261
 AliEMCALRecoUtils.cxx:262
 AliEMCALRecoUtils.cxx:263
 AliEMCALRecoUtils.cxx:264
 AliEMCALRecoUtils.cxx:265
 AliEMCALRecoUtils.cxx:266
 AliEMCALRecoUtils.cxx:267
 AliEMCALRecoUtils.cxx:268
 AliEMCALRecoUtils.cxx:269
 AliEMCALRecoUtils.cxx:270
 AliEMCALRecoUtils.cxx:271
 AliEMCALRecoUtils.cxx:272
 AliEMCALRecoUtils.cxx:273
 AliEMCALRecoUtils.cxx:274
 AliEMCALRecoUtils.cxx:275
 AliEMCALRecoUtils.cxx:276
 AliEMCALRecoUtils.cxx:277
 AliEMCALRecoUtils.cxx:278
 AliEMCALRecoUtils.cxx:279
 AliEMCALRecoUtils.cxx:280
 AliEMCALRecoUtils.cxx:281
 AliEMCALRecoUtils.cxx:282
 AliEMCALRecoUtils.cxx:283
 AliEMCALRecoUtils.cxx:284
 AliEMCALRecoUtils.cxx:285
 AliEMCALRecoUtils.cxx:286
 AliEMCALRecoUtils.cxx:287
 AliEMCALRecoUtils.cxx:288
 AliEMCALRecoUtils.cxx:289
 AliEMCALRecoUtils.cxx:290
 AliEMCALRecoUtils.cxx:291
 AliEMCALRecoUtils.cxx:292
 AliEMCALRecoUtils.cxx:293
 AliEMCALRecoUtils.cxx:294
 AliEMCALRecoUtils.cxx:295
 AliEMCALRecoUtils.cxx:296
 AliEMCALRecoUtils.cxx:297
 AliEMCALRecoUtils.cxx:298
 AliEMCALRecoUtils.cxx:299
 AliEMCALRecoUtils.cxx:300
 AliEMCALRecoUtils.cxx:301
 AliEMCALRecoUtils.cxx:302
 AliEMCALRecoUtils.cxx:303
 AliEMCALRecoUtils.cxx:304
 AliEMCALRecoUtils.cxx:305
 AliEMCALRecoUtils.cxx:306
 AliEMCALRecoUtils.cxx:307
 AliEMCALRecoUtils.cxx:308
 AliEMCALRecoUtils.cxx:309
 AliEMCALRecoUtils.cxx:310
 AliEMCALRecoUtils.cxx:311
 AliEMCALRecoUtils.cxx:312
 AliEMCALRecoUtils.cxx:313
 AliEMCALRecoUtils.cxx:314
 AliEMCALRecoUtils.cxx:315
 AliEMCALRecoUtils.cxx:316
 AliEMCALRecoUtils.cxx:317
 AliEMCALRecoUtils.cxx:318
 AliEMCALRecoUtils.cxx:319
 AliEMCALRecoUtils.cxx:320
 AliEMCALRecoUtils.cxx:321
 AliEMCALRecoUtils.cxx:322
 AliEMCALRecoUtils.cxx:323
 AliEMCALRecoUtils.cxx:324
 AliEMCALRecoUtils.cxx:325
 AliEMCALRecoUtils.cxx:326
 AliEMCALRecoUtils.cxx:327
 AliEMCALRecoUtils.cxx:328
 AliEMCALRecoUtils.cxx:329
 AliEMCALRecoUtils.cxx:330
 AliEMCALRecoUtils.cxx:331
 AliEMCALRecoUtils.cxx:332
 AliEMCALRecoUtils.cxx:333
 AliEMCALRecoUtils.cxx:334
 AliEMCALRecoUtils.cxx:335
 AliEMCALRecoUtils.cxx:336
 AliEMCALRecoUtils.cxx:337
 AliEMCALRecoUtils.cxx:338
 AliEMCALRecoUtils.cxx:339
 AliEMCALRecoUtils.cxx:340
 AliEMCALRecoUtils.cxx:341
 AliEMCALRecoUtils.cxx:342
 AliEMCALRecoUtils.cxx:343
 AliEMCALRecoUtils.cxx:344
 AliEMCALRecoUtils.cxx:345
 AliEMCALRecoUtils.cxx:346
 AliEMCALRecoUtils.cxx:347
 AliEMCALRecoUtils.cxx:348
 AliEMCALRecoUtils.cxx:349
 AliEMCALRecoUtils.cxx:350
 AliEMCALRecoUtils.cxx:351
 AliEMCALRecoUtils.cxx:352
 AliEMCALRecoUtils.cxx:353
 AliEMCALRecoUtils.cxx:354
 AliEMCALRecoUtils.cxx:355
 AliEMCALRecoUtils.cxx:356
 AliEMCALRecoUtils.cxx:357
 AliEMCALRecoUtils.cxx:358
 AliEMCALRecoUtils.cxx:359
 AliEMCALRecoUtils.cxx:360
 AliEMCALRecoUtils.cxx:361
 AliEMCALRecoUtils.cxx:362
 AliEMCALRecoUtils.cxx:363
 AliEMCALRecoUtils.cxx:364
 AliEMCALRecoUtils.cxx:365
 AliEMCALRecoUtils.cxx:366
 AliEMCALRecoUtils.cxx:367
 AliEMCALRecoUtils.cxx:368
 AliEMCALRecoUtils.cxx:369
 AliEMCALRecoUtils.cxx:370
 AliEMCALRecoUtils.cxx:371
 AliEMCALRecoUtils.cxx:372
 AliEMCALRecoUtils.cxx:373
 AliEMCALRecoUtils.cxx:374
 AliEMCALRecoUtils.cxx:375
 AliEMCALRecoUtils.cxx:376
 AliEMCALRecoUtils.cxx:377
 AliEMCALRecoUtils.cxx:378
 AliEMCALRecoUtils.cxx:379
 AliEMCALRecoUtils.cxx:380
 AliEMCALRecoUtils.cxx:381
 AliEMCALRecoUtils.cxx:382
 AliEMCALRecoUtils.cxx:383
 AliEMCALRecoUtils.cxx:384
 AliEMCALRecoUtils.cxx:385
 AliEMCALRecoUtils.cxx:386
 AliEMCALRecoUtils.cxx:387
 AliEMCALRecoUtils.cxx:388
 AliEMCALRecoUtils.cxx:389
 AliEMCALRecoUtils.cxx:390
 AliEMCALRecoUtils.cxx:391
 AliEMCALRecoUtils.cxx:392
 AliEMCALRecoUtils.cxx:393
 AliEMCALRecoUtils.cxx:394
 AliEMCALRecoUtils.cxx:395
 AliEMCALRecoUtils.cxx:396
 AliEMCALRecoUtils.cxx:397
 AliEMCALRecoUtils.cxx:398
 AliEMCALRecoUtils.cxx:399
 AliEMCALRecoUtils.cxx:400
 AliEMCALRecoUtils.cxx:401
 AliEMCALRecoUtils.cxx:402
 AliEMCALRecoUtils.cxx:403
 AliEMCALRecoUtils.cxx:404
 AliEMCALRecoUtils.cxx:405
 AliEMCALRecoUtils.cxx:406
 AliEMCALRecoUtils.cxx:407
 AliEMCALRecoUtils.cxx:408
 AliEMCALRecoUtils.cxx:409
 AliEMCALRecoUtils.cxx:410
 AliEMCALRecoUtils.cxx:411
 AliEMCALRecoUtils.cxx:412
 AliEMCALRecoUtils.cxx:413
 AliEMCALRecoUtils.cxx:414
 AliEMCALRecoUtils.cxx:415
 AliEMCALRecoUtils.cxx:416
 AliEMCALRecoUtils.cxx:417
 AliEMCALRecoUtils.cxx:418
 AliEMCALRecoUtils.cxx:419
 AliEMCALRecoUtils.cxx:420
 AliEMCALRecoUtils.cxx:421
 AliEMCALRecoUtils.cxx:422
 AliEMCALRecoUtils.cxx:423
 AliEMCALRecoUtils.cxx:424
 AliEMCALRecoUtils.cxx:425
 AliEMCALRecoUtils.cxx:426
 AliEMCALRecoUtils.cxx:427
 AliEMCALRecoUtils.cxx:428
 AliEMCALRecoUtils.cxx:429
 AliEMCALRecoUtils.cxx:430
 AliEMCALRecoUtils.cxx:431
 AliEMCALRecoUtils.cxx:432
 AliEMCALRecoUtils.cxx:433
 AliEMCALRecoUtils.cxx:434
 AliEMCALRecoUtils.cxx:435
 AliEMCALRecoUtils.cxx:436
 AliEMCALRecoUtils.cxx:437
 AliEMCALRecoUtils.cxx:438
 AliEMCALRecoUtils.cxx:439
 AliEMCALRecoUtils.cxx:440
 AliEMCALRecoUtils.cxx:441
 AliEMCALRecoUtils.cxx:442
 AliEMCALRecoUtils.cxx:443
 AliEMCALRecoUtils.cxx:444
 AliEMCALRecoUtils.cxx:445
 AliEMCALRecoUtils.cxx:446
 AliEMCALRecoUtils.cxx:447
 AliEMCALRecoUtils.cxx:448
 AliEMCALRecoUtils.cxx:449
 AliEMCALRecoUtils.cxx:450
 AliEMCALRecoUtils.cxx:451
 AliEMCALRecoUtils.cxx:452
 AliEMCALRecoUtils.cxx:453
 AliEMCALRecoUtils.cxx:454
 AliEMCALRecoUtils.cxx:455
 AliEMCALRecoUtils.cxx:456
 AliEMCALRecoUtils.cxx:457
 AliEMCALRecoUtils.cxx:458
 AliEMCALRecoUtils.cxx:459
 AliEMCALRecoUtils.cxx:460
 AliEMCALRecoUtils.cxx:461
 AliEMCALRecoUtils.cxx:462
 AliEMCALRecoUtils.cxx:463
 AliEMCALRecoUtils.cxx:464
 AliEMCALRecoUtils.cxx:465
 AliEMCALRecoUtils.cxx:466
 AliEMCALRecoUtils.cxx:467
 AliEMCALRecoUtils.cxx:468
 AliEMCALRecoUtils.cxx:469
 AliEMCALRecoUtils.cxx:470
 AliEMCALRecoUtils.cxx:471
 AliEMCALRecoUtils.cxx:472
 AliEMCALRecoUtils.cxx:473
 AliEMCALRecoUtils.cxx:474
 AliEMCALRecoUtils.cxx:475
 AliEMCALRecoUtils.cxx:476
 AliEMCALRecoUtils.cxx:477
 AliEMCALRecoUtils.cxx:478
 AliEMCALRecoUtils.cxx:479
 AliEMCALRecoUtils.cxx:480
 AliEMCALRecoUtils.cxx:481
 AliEMCALRecoUtils.cxx:482
 AliEMCALRecoUtils.cxx:483
 AliEMCALRecoUtils.cxx:484
 AliEMCALRecoUtils.cxx:485
 AliEMCALRecoUtils.cxx:486
 AliEMCALRecoUtils.cxx:487
 AliEMCALRecoUtils.cxx:488
 AliEMCALRecoUtils.cxx:489
 AliEMCALRecoUtils.cxx:490
 AliEMCALRecoUtils.cxx:491
 AliEMCALRecoUtils.cxx:492
 AliEMCALRecoUtils.cxx:493
 AliEMCALRecoUtils.cxx:494
 AliEMCALRecoUtils.cxx:495
 AliEMCALRecoUtils.cxx:496
 AliEMCALRecoUtils.cxx:497
 AliEMCALRecoUtils.cxx:498
 AliEMCALRecoUtils.cxx:499
 AliEMCALRecoUtils.cxx:500
 AliEMCALRecoUtils.cxx:501
 AliEMCALRecoUtils.cxx:502
 AliEMCALRecoUtils.cxx:503
 AliEMCALRecoUtils.cxx:504
 AliEMCALRecoUtils.cxx:505
 AliEMCALRecoUtils.cxx:506
 AliEMCALRecoUtils.cxx:507
 AliEMCALRecoUtils.cxx:508
 AliEMCALRecoUtils.cxx:509
 AliEMCALRecoUtils.cxx:510
 AliEMCALRecoUtils.cxx:511
 AliEMCALRecoUtils.cxx:512
 AliEMCALRecoUtils.cxx:513
 AliEMCALRecoUtils.cxx:514
 AliEMCALRecoUtils.cxx:515
 AliEMCALRecoUtils.cxx:516
 AliEMCALRecoUtils.cxx:517
 AliEMCALRecoUtils.cxx:518
 AliEMCALRecoUtils.cxx:519
 AliEMCALRecoUtils.cxx:520
 AliEMCALRecoUtils.cxx:521
 AliEMCALRecoUtils.cxx:522
 AliEMCALRecoUtils.cxx:523
 AliEMCALRecoUtils.cxx:524
 AliEMCALRecoUtils.cxx:525
 AliEMCALRecoUtils.cxx:526
 AliEMCALRecoUtils.cxx:527
 AliEMCALRecoUtils.cxx:528
 AliEMCALRecoUtils.cxx:529
 AliEMCALRecoUtils.cxx:530
 AliEMCALRecoUtils.cxx:531
 AliEMCALRecoUtils.cxx:532
 AliEMCALRecoUtils.cxx:533
 AliEMCALRecoUtils.cxx:534
 AliEMCALRecoUtils.cxx:535
 AliEMCALRecoUtils.cxx:536
 AliEMCALRecoUtils.cxx:537
 AliEMCALRecoUtils.cxx:538
 AliEMCALRecoUtils.cxx:539
 AliEMCALRecoUtils.cxx:540
 AliEMCALRecoUtils.cxx:541
 AliEMCALRecoUtils.cxx:542
 AliEMCALRecoUtils.cxx:543
 AliEMCALRecoUtils.cxx:544
 AliEMCALRecoUtils.cxx:545
 AliEMCALRecoUtils.cxx:546
 AliEMCALRecoUtils.cxx:547
 AliEMCALRecoUtils.cxx:548
 AliEMCALRecoUtils.cxx:549
 AliEMCALRecoUtils.cxx:550
 AliEMCALRecoUtils.cxx:551
 AliEMCALRecoUtils.cxx:552
 AliEMCALRecoUtils.cxx:553
 AliEMCALRecoUtils.cxx:554
 AliEMCALRecoUtils.cxx:555
 AliEMCALRecoUtils.cxx:556
 AliEMCALRecoUtils.cxx:557
 AliEMCALRecoUtils.cxx:558
 AliEMCALRecoUtils.cxx:559
 AliEMCALRecoUtils.cxx:560
 AliEMCALRecoUtils.cxx:561
 AliEMCALRecoUtils.cxx:562
 AliEMCALRecoUtils.cxx:563
 AliEMCALRecoUtils.cxx:564
 AliEMCALRecoUtils.cxx:565
 AliEMCALRecoUtils.cxx:566
 AliEMCALRecoUtils.cxx:567
 AliEMCALRecoUtils.cxx:568
 AliEMCALRecoUtils.cxx:569
 AliEMCALRecoUtils.cxx:570
 AliEMCALRecoUtils.cxx:571
 AliEMCALRecoUtils.cxx:572
 AliEMCALRecoUtils.cxx:573
 AliEMCALRecoUtils.cxx:574
 AliEMCALRecoUtils.cxx:575
 AliEMCALRecoUtils.cxx:576
 AliEMCALRecoUtils.cxx:577
 AliEMCALRecoUtils.cxx:578
 AliEMCALRecoUtils.cxx:579
 AliEMCALRecoUtils.cxx:580
 AliEMCALRecoUtils.cxx:581
 AliEMCALRecoUtils.cxx:582
 AliEMCALRecoUtils.cxx:583
 AliEMCALRecoUtils.cxx:584
 AliEMCALRecoUtils.cxx:585
 AliEMCALRecoUtils.cxx:586
 AliEMCALRecoUtils.cxx:587
 AliEMCALRecoUtils.cxx:588
 AliEMCALRecoUtils.cxx:589
 AliEMCALRecoUtils.cxx:590
 AliEMCALRecoUtils.cxx:591
 AliEMCALRecoUtils.cxx:592
 AliEMCALRecoUtils.cxx:593
 AliEMCALRecoUtils.cxx:594
 AliEMCALRecoUtils.cxx:595
 AliEMCALRecoUtils.cxx:596
 AliEMCALRecoUtils.cxx:597
 AliEMCALRecoUtils.cxx:598
 AliEMCALRecoUtils.cxx:599
 AliEMCALRecoUtils.cxx:600
 AliEMCALRecoUtils.cxx:601
 AliEMCALRecoUtils.cxx:602
 AliEMCALRecoUtils.cxx:603
 AliEMCALRecoUtils.cxx:604
 AliEMCALRecoUtils.cxx:605
 AliEMCALRecoUtils.cxx:606
 AliEMCALRecoUtils.cxx:607
 AliEMCALRecoUtils.cxx:608
 AliEMCALRecoUtils.cxx:609
 AliEMCALRecoUtils.cxx:610
 AliEMCALRecoUtils.cxx:611
 AliEMCALRecoUtils.cxx:612
 AliEMCALRecoUtils.cxx:613
 AliEMCALRecoUtils.cxx:614
 AliEMCALRecoUtils.cxx:615
 AliEMCALRecoUtils.cxx:616
 AliEMCALRecoUtils.cxx:617
 AliEMCALRecoUtils.cxx:618
 AliEMCALRecoUtils.cxx:619
 AliEMCALRecoUtils.cxx:620
 AliEMCALRecoUtils.cxx:621
 AliEMCALRecoUtils.cxx:622
 AliEMCALRecoUtils.cxx:623
 AliEMCALRecoUtils.cxx:624
 AliEMCALRecoUtils.cxx:625
 AliEMCALRecoUtils.cxx:626
 AliEMCALRecoUtils.cxx:627
 AliEMCALRecoUtils.cxx:628
 AliEMCALRecoUtils.cxx:629
 AliEMCALRecoUtils.cxx:630
 AliEMCALRecoUtils.cxx:631
 AliEMCALRecoUtils.cxx:632
 AliEMCALRecoUtils.cxx:633
 AliEMCALRecoUtils.cxx:634
 AliEMCALRecoUtils.cxx:635
 AliEMCALRecoUtils.cxx:636
 AliEMCALRecoUtils.cxx:637
 AliEMCALRecoUtils.cxx:638
 AliEMCALRecoUtils.cxx:639
 AliEMCALRecoUtils.cxx:640
 AliEMCALRecoUtils.cxx:641
 AliEMCALRecoUtils.cxx:642
 AliEMCALRecoUtils.cxx:643
 AliEMCALRecoUtils.cxx:644
 AliEMCALRecoUtils.cxx:645
 AliEMCALRecoUtils.cxx:646
 AliEMCALRecoUtils.cxx:647
 AliEMCALRecoUtils.cxx:648
 AliEMCALRecoUtils.cxx:649
 AliEMCALRecoUtils.cxx:650
 AliEMCALRecoUtils.cxx:651
 AliEMCALRecoUtils.cxx:652
 AliEMCALRecoUtils.cxx:653
 AliEMCALRecoUtils.cxx:654
 AliEMCALRecoUtils.cxx:655
 AliEMCALRecoUtils.cxx:656
 AliEMCALRecoUtils.cxx:657
 AliEMCALRecoUtils.cxx:658
 AliEMCALRecoUtils.cxx:659
 AliEMCALRecoUtils.cxx:660
 AliEMCALRecoUtils.cxx:661
 AliEMCALRecoUtils.cxx:662
 AliEMCALRecoUtils.cxx:663
 AliEMCALRecoUtils.cxx:664
 AliEMCALRecoUtils.cxx:665
 AliEMCALRecoUtils.cxx:666
 AliEMCALRecoUtils.cxx:667
 AliEMCALRecoUtils.cxx:668
 AliEMCALRecoUtils.cxx:669
 AliEMCALRecoUtils.cxx:670
 AliEMCALRecoUtils.cxx:671
 AliEMCALRecoUtils.cxx:672
 AliEMCALRecoUtils.cxx:673
 AliEMCALRecoUtils.cxx:674
 AliEMCALRecoUtils.cxx:675
 AliEMCALRecoUtils.cxx:676
 AliEMCALRecoUtils.cxx:677
 AliEMCALRecoUtils.cxx:678
 AliEMCALRecoUtils.cxx:679
 AliEMCALRecoUtils.cxx:680
 AliEMCALRecoUtils.cxx:681
 AliEMCALRecoUtils.cxx:682
 AliEMCALRecoUtils.cxx:683
 AliEMCALRecoUtils.cxx:684
 AliEMCALRecoUtils.cxx:685
 AliEMCALRecoUtils.cxx:686
 AliEMCALRecoUtils.cxx:687
 AliEMCALRecoUtils.cxx:688
 AliEMCALRecoUtils.cxx:689
 AliEMCALRecoUtils.cxx:690
 AliEMCALRecoUtils.cxx:691
 AliEMCALRecoUtils.cxx:692
 AliEMCALRecoUtils.cxx:693
 AliEMCALRecoUtils.cxx:694
 AliEMCALRecoUtils.cxx:695
 AliEMCALRecoUtils.cxx:696
 AliEMCALRecoUtils.cxx:697
 AliEMCALRecoUtils.cxx:698
 AliEMCALRecoUtils.cxx:699
 AliEMCALRecoUtils.cxx:700
 AliEMCALRecoUtils.cxx:701
 AliEMCALRecoUtils.cxx:702
 AliEMCALRecoUtils.cxx:703
 AliEMCALRecoUtils.cxx:704
 AliEMCALRecoUtils.cxx:705
 AliEMCALRecoUtils.cxx:706
 AliEMCALRecoUtils.cxx:707
 AliEMCALRecoUtils.cxx:708
 AliEMCALRecoUtils.cxx:709
 AliEMCALRecoUtils.cxx:710
 AliEMCALRecoUtils.cxx:711
 AliEMCALRecoUtils.cxx:712
 AliEMCALRecoUtils.cxx:713
 AliEMCALRecoUtils.cxx:714
 AliEMCALRecoUtils.cxx:715
 AliEMCALRecoUtils.cxx:716
 AliEMCALRecoUtils.cxx:717
 AliEMCALRecoUtils.cxx:718
 AliEMCALRecoUtils.cxx:719
 AliEMCALRecoUtils.cxx:720
 AliEMCALRecoUtils.cxx:721
 AliEMCALRecoUtils.cxx:722
 AliEMCALRecoUtils.cxx:723
 AliEMCALRecoUtils.cxx:724
 AliEMCALRecoUtils.cxx:725
 AliEMCALRecoUtils.cxx:726
 AliEMCALRecoUtils.cxx:727
 AliEMCALRecoUtils.cxx:728
 AliEMCALRecoUtils.cxx:729
 AliEMCALRecoUtils.cxx:730
 AliEMCALRecoUtils.cxx:731
 AliEMCALRecoUtils.cxx:732
 AliEMCALRecoUtils.cxx:733
 AliEMCALRecoUtils.cxx:734
 AliEMCALRecoUtils.cxx:735
 AliEMCALRecoUtils.cxx:736
 AliEMCALRecoUtils.cxx:737
 AliEMCALRecoUtils.cxx:738
 AliEMCALRecoUtils.cxx:739
 AliEMCALRecoUtils.cxx:740
 AliEMCALRecoUtils.cxx:741
 AliEMCALRecoUtils.cxx:742
 AliEMCALRecoUtils.cxx:743
 AliEMCALRecoUtils.cxx:744
 AliEMCALRecoUtils.cxx:745
 AliEMCALRecoUtils.cxx:746
 AliEMCALRecoUtils.cxx:747
 AliEMCALRecoUtils.cxx:748
 AliEMCALRecoUtils.cxx:749
 AliEMCALRecoUtils.cxx:750
 AliEMCALRecoUtils.cxx:751
 AliEMCALRecoUtils.cxx:752
 AliEMCALRecoUtils.cxx:753
 AliEMCALRecoUtils.cxx:754
 AliEMCALRecoUtils.cxx:755
 AliEMCALRecoUtils.cxx:756
 AliEMCALRecoUtils.cxx:757
 AliEMCALRecoUtils.cxx:758
 AliEMCALRecoUtils.cxx:759
 AliEMCALRecoUtils.cxx:760
 AliEMCALRecoUtils.cxx:761
 AliEMCALRecoUtils.cxx:762
 AliEMCALRecoUtils.cxx:763
 AliEMCALRecoUtils.cxx:764
 AliEMCALRecoUtils.cxx:765
 AliEMCALRecoUtils.cxx:766
 AliEMCALRecoUtils.cxx:767
 AliEMCALRecoUtils.cxx:768
 AliEMCALRecoUtils.cxx:769
 AliEMCALRecoUtils.cxx:770
 AliEMCALRecoUtils.cxx:771
 AliEMCALRecoUtils.cxx:772
 AliEMCALRecoUtils.cxx:773
 AliEMCALRecoUtils.cxx:774
 AliEMCALRecoUtils.cxx:775
 AliEMCALRecoUtils.cxx:776
 AliEMCALRecoUtils.cxx:777
 AliEMCALRecoUtils.cxx:778
 AliEMCALRecoUtils.cxx:779
 AliEMCALRecoUtils.cxx:780
 AliEMCALRecoUtils.cxx:781
 AliEMCALRecoUtils.cxx:782
 AliEMCALRecoUtils.cxx:783
 AliEMCALRecoUtils.cxx:784
 AliEMCALRecoUtils.cxx:785
 AliEMCALRecoUtils.cxx:786
 AliEMCALRecoUtils.cxx:787
 AliEMCALRecoUtils.cxx:788
 AliEMCALRecoUtils.cxx:789
 AliEMCALRecoUtils.cxx:790
 AliEMCALRecoUtils.cxx:791
 AliEMCALRecoUtils.cxx:792
 AliEMCALRecoUtils.cxx:793
 AliEMCALRecoUtils.cxx:794
 AliEMCALRecoUtils.cxx:795
 AliEMCALRecoUtils.cxx:796
 AliEMCALRecoUtils.cxx:797
 AliEMCALRecoUtils.cxx:798
 AliEMCALRecoUtils.cxx:799
 AliEMCALRecoUtils.cxx:800
 AliEMCALRecoUtils.cxx:801
 AliEMCALRecoUtils.cxx:802
 AliEMCALRecoUtils.cxx:803
 AliEMCALRecoUtils.cxx:804
 AliEMCALRecoUtils.cxx:805
 AliEMCALRecoUtils.cxx:806
 AliEMCALRecoUtils.cxx:807
 AliEMCALRecoUtils.cxx:808
 AliEMCALRecoUtils.cxx:809
 AliEMCALRecoUtils.cxx:810
 AliEMCALRecoUtils.cxx:811
 AliEMCALRecoUtils.cxx:812
 AliEMCALRecoUtils.cxx:813
 AliEMCALRecoUtils.cxx:814
 AliEMCALRecoUtils.cxx:815
 AliEMCALRecoUtils.cxx:816
 AliEMCALRecoUtils.cxx:817
 AliEMCALRecoUtils.cxx:818
 AliEMCALRecoUtils.cxx:819
 AliEMCALRecoUtils.cxx:820
 AliEMCALRecoUtils.cxx:821
 AliEMCALRecoUtils.cxx:822
 AliEMCALRecoUtils.cxx:823
 AliEMCALRecoUtils.cxx:824
 AliEMCALRecoUtils.cxx:825
 AliEMCALRecoUtils.cxx:826
 AliEMCALRecoUtils.cxx:827
 AliEMCALRecoUtils.cxx:828
 AliEMCALRecoUtils.cxx:829
 AliEMCALRecoUtils.cxx:830
 AliEMCALRecoUtils.cxx:831
 AliEMCALRecoUtils.cxx:832
 AliEMCALRecoUtils.cxx:833
 AliEMCALRecoUtils.cxx:834
 AliEMCALRecoUtils.cxx:835
 AliEMCALRecoUtils.cxx:836
 AliEMCALRecoUtils.cxx:837
 AliEMCALRecoUtils.cxx:838
 AliEMCALRecoUtils.cxx:839
 AliEMCALRecoUtils.cxx:840
 AliEMCALRecoUtils.cxx:841
 AliEMCALRecoUtils.cxx:842
 AliEMCALRecoUtils.cxx:843
 AliEMCALRecoUtils.cxx:844
 AliEMCALRecoUtils.cxx:845
 AliEMCALRecoUtils.cxx:846
 AliEMCALRecoUtils.cxx:847
 AliEMCALRecoUtils.cxx:848
 AliEMCALRecoUtils.cxx:849
 AliEMCALRecoUtils.cxx:850
 AliEMCALRecoUtils.cxx:851
 AliEMCALRecoUtils.cxx:852
 AliEMCALRecoUtils.cxx:853
 AliEMCALRecoUtils.cxx:854
 AliEMCALRecoUtils.cxx:855
 AliEMCALRecoUtils.cxx:856
 AliEMCALRecoUtils.cxx:857
 AliEMCALRecoUtils.cxx:858
 AliEMCALRecoUtils.cxx:859
 AliEMCALRecoUtils.cxx:860
 AliEMCALRecoUtils.cxx:861
 AliEMCALRecoUtils.cxx:862
 AliEMCALRecoUtils.cxx:863
 AliEMCALRecoUtils.cxx:864
 AliEMCALRecoUtils.cxx:865
 AliEMCALRecoUtils.cxx:866
 AliEMCALRecoUtils.cxx:867
 AliEMCALRecoUtils.cxx:868
 AliEMCALRecoUtils.cxx:869
 AliEMCALRecoUtils.cxx:870
 AliEMCALRecoUtils.cxx:871
 AliEMCALRecoUtils.cxx:872
 AliEMCALRecoUtils.cxx:873
 AliEMCALRecoUtils.cxx:874
 AliEMCALRecoUtils.cxx:875
 AliEMCALRecoUtils.cxx:876
 AliEMCALRecoUtils.cxx:877
 AliEMCALRecoUtils.cxx:878
 AliEMCALRecoUtils.cxx:879
 AliEMCALRecoUtils.cxx:880
 AliEMCALRecoUtils.cxx:881
 AliEMCALRecoUtils.cxx:882
 AliEMCALRecoUtils.cxx:883
 AliEMCALRecoUtils.cxx:884
 AliEMCALRecoUtils.cxx:885
 AliEMCALRecoUtils.cxx:886
 AliEMCALRecoUtils.cxx:887
 AliEMCALRecoUtils.cxx:888
 AliEMCALRecoUtils.cxx:889
 AliEMCALRecoUtils.cxx:890
 AliEMCALRecoUtils.cxx:891
 AliEMCALRecoUtils.cxx:892
 AliEMCALRecoUtils.cxx:893
 AliEMCALRecoUtils.cxx:894
 AliEMCALRecoUtils.cxx:895
 AliEMCALRecoUtils.cxx:896
 AliEMCALRecoUtils.cxx:897
 AliEMCALRecoUtils.cxx:898
 AliEMCALRecoUtils.cxx:899
 AliEMCALRecoUtils.cxx:900
 AliEMCALRecoUtils.cxx:901
 AliEMCALRecoUtils.cxx:902
 AliEMCALRecoUtils.cxx:903
 AliEMCALRecoUtils.cxx:904
 AliEMCALRecoUtils.cxx:905
 AliEMCALRecoUtils.cxx:906
 AliEMCALRecoUtils.cxx:907
 AliEMCALRecoUtils.cxx:908
 AliEMCALRecoUtils.cxx:909
 AliEMCALRecoUtils.cxx:910
 AliEMCALRecoUtils.cxx:911
 AliEMCALRecoUtils.cxx:912
 AliEMCALRecoUtils.cxx:913
 AliEMCALRecoUtils.cxx:914
 AliEMCALRecoUtils.cxx:915
 AliEMCALRecoUtils.cxx:916
 AliEMCALRecoUtils.cxx:917
 AliEMCALRecoUtils.cxx:918
 AliEMCALRecoUtils.cxx:919
 AliEMCALRecoUtils.cxx:920
 AliEMCALRecoUtils.cxx:921
 AliEMCALRecoUtils.cxx:922
 AliEMCALRecoUtils.cxx:923
 AliEMCALRecoUtils.cxx:924
 AliEMCALRecoUtils.cxx:925
 AliEMCALRecoUtils.cxx:926
 AliEMCALRecoUtils.cxx:927
 AliEMCALRecoUtils.cxx:928
 AliEMCALRecoUtils.cxx:929
 AliEMCALRecoUtils.cxx:930
 AliEMCALRecoUtils.cxx:931
 AliEMCALRecoUtils.cxx:932
 AliEMCALRecoUtils.cxx:933
 AliEMCALRecoUtils.cxx:934
 AliEMCALRecoUtils.cxx:935
 AliEMCALRecoUtils.cxx:936
 AliEMCALRecoUtils.cxx:937
 AliEMCALRecoUtils.cxx:938
 AliEMCALRecoUtils.cxx:939
 AliEMCALRecoUtils.cxx:940
 AliEMCALRecoUtils.cxx:941
 AliEMCALRecoUtils.cxx:942
 AliEMCALRecoUtils.cxx:943
 AliEMCALRecoUtils.cxx:944
 AliEMCALRecoUtils.cxx:945
 AliEMCALRecoUtils.cxx:946
 AliEMCALRecoUtils.cxx:947
 AliEMCALRecoUtils.cxx:948
 AliEMCALRecoUtils.cxx:949
 AliEMCALRecoUtils.cxx:950
 AliEMCALRecoUtils.cxx:951
 AliEMCALRecoUtils.cxx:952
 AliEMCALRecoUtils.cxx:953
 AliEMCALRecoUtils.cxx:954
 AliEMCALRecoUtils.cxx:955
 AliEMCALRecoUtils.cxx:956
 AliEMCALRecoUtils.cxx:957
 AliEMCALRecoUtils.cxx:958
 AliEMCALRecoUtils.cxx:959
 AliEMCALRecoUtils.cxx:960
 AliEMCALRecoUtils.cxx:961
 AliEMCALRecoUtils.cxx:962
 AliEMCALRecoUtils.cxx:963
 AliEMCALRecoUtils.cxx:964
 AliEMCALRecoUtils.cxx:965
 AliEMCALRecoUtils.cxx:966
 AliEMCALRecoUtils.cxx:967
 AliEMCALRecoUtils.cxx:968
 AliEMCALRecoUtils.cxx:969
 AliEMCALRecoUtils.cxx:970
 AliEMCALRecoUtils.cxx:971
 AliEMCALRecoUtils.cxx:972
 AliEMCALRecoUtils.cxx:973
 AliEMCALRecoUtils.cxx:974
 AliEMCALRecoUtils.cxx:975
 AliEMCALRecoUtils.cxx:976
 AliEMCALRecoUtils.cxx:977
 AliEMCALRecoUtils.cxx:978
 AliEMCALRecoUtils.cxx:979
 AliEMCALRecoUtils.cxx:980
 AliEMCALRecoUtils.cxx:981
 AliEMCALRecoUtils.cxx:982
 AliEMCALRecoUtils.cxx:983
 AliEMCALRecoUtils.cxx:984
 AliEMCALRecoUtils.cxx:985
 AliEMCALRecoUtils.cxx:986
 AliEMCALRecoUtils.cxx:987
 AliEMCALRecoUtils.cxx:988
 AliEMCALRecoUtils.cxx:989
 AliEMCALRecoUtils.cxx:990
 AliEMCALRecoUtils.cxx:991
 AliEMCALRecoUtils.cxx:992
 AliEMCALRecoUtils.cxx:993
 AliEMCALRecoUtils.cxx:994
 AliEMCALRecoUtils.cxx:995
 AliEMCALRecoUtils.cxx:996
 AliEMCALRecoUtils.cxx:997
 AliEMCALRecoUtils.cxx:998
 AliEMCALRecoUtils.cxx:999
 AliEMCALRecoUtils.cxx:1000
 AliEMCALRecoUtils.cxx:1001
 AliEMCALRecoUtils.cxx:1002
 AliEMCALRecoUtils.cxx:1003
 AliEMCALRecoUtils.cxx:1004
 AliEMCALRecoUtils.cxx:1005
 AliEMCALRecoUtils.cxx:1006
 AliEMCALRecoUtils.cxx:1007
 AliEMCALRecoUtils.cxx:1008
 AliEMCALRecoUtils.cxx:1009
 AliEMCALRecoUtils.cxx:1010
 AliEMCALRecoUtils.cxx:1011
 AliEMCALRecoUtils.cxx:1012
 AliEMCALRecoUtils.cxx:1013
 AliEMCALRecoUtils.cxx:1014
 AliEMCALRecoUtils.cxx:1015
 AliEMCALRecoUtils.cxx:1016
 AliEMCALRecoUtils.cxx:1017
 AliEMCALRecoUtils.cxx:1018
 AliEMCALRecoUtils.cxx:1019
 AliEMCALRecoUtils.cxx:1020
 AliEMCALRecoUtils.cxx:1021
 AliEMCALRecoUtils.cxx:1022
 AliEMCALRecoUtils.cxx:1023
 AliEMCALRecoUtils.cxx:1024
 AliEMCALRecoUtils.cxx:1025
 AliEMCALRecoUtils.cxx:1026
 AliEMCALRecoUtils.cxx:1027
 AliEMCALRecoUtils.cxx:1028
 AliEMCALRecoUtils.cxx:1029
 AliEMCALRecoUtils.cxx:1030
 AliEMCALRecoUtils.cxx:1031
 AliEMCALRecoUtils.cxx:1032
 AliEMCALRecoUtils.cxx:1033
 AliEMCALRecoUtils.cxx:1034
 AliEMCALRecoUtils.cxx:1035
 AliEMCALRecoUtils.cxx:1036
 AliEMCALRecoUtils.cxx:1037
 AliEMCALRecoUtils.cxx:1038
 AliEMCALRecoUtils.cxx:1039
 AliEMCALRecoUtils.cxx:1040
 AliEMCALRecoUtils.cxx:1041
 AliEMCALRecoUtils.cxx:1042
 AliEMCALRecoUtils.cxx:1043
 AliEMCALRecoUtils.cxx:1044
 AliEMCALRecoUtils.cxx:1045
 AliEMCALRecoUtils.cxx:1046
 AliEMCALRecoUtils.cxx:1047
 AliEMCALRecoUtils.cxx:1048
 AliEMCALRecoUtils.cxx:1049
 AliEMCALRecoUtils.cxx:1050
 AliEMCALRecoUtils.cxx:1051
 AliEMCALRecoUtils.cxx:1052
 AliEMCALRecoUtils.cxx:1053
 AliEMCALRecoUtils.cxx:1054
 AliEMCALRecoUtils.cxx:1055
 AliEMCALRecoUtils.cxx:1056
 AliEMCALRecoUtils.cxx:1057
 AliEMCALRecoUtils.cxx:1058
 AliEMCALRecoUtils.cxx:1059
 AliEMCALRecoUtils.cxx:1060
 AliEMCALRecoUtils.cxx:1061
 AliEMCALRecoUtils.cxx:1062
 AliEMCALRecoUtils.cxx:1063
 AliEMCALRecoUtils.cxx:1064
 AliEMCALRecoUtils.cxx:1065
 AliEMCALRecoUtils.cxx:1066
 AliEMCALRecoUtils.cxx:1067
 AliEMCALRecoUtils.cxx:1068
 AliEMCALRecoUtils.cxx:1069
 AliEMCALRecoUtils.cxx:1070
 AliEMCALRecoUtils.cxx:1071
 AliEMCALRecoUtils.cxx:1072
 AliEMCALRecoUtils.cxx:1073
 AliEMCALRecoUtils.cxx:1074
 AliEMCALRecoUtils.cxx:1075
 AliEMCALRecoUtils.cxx:1076
 AliEMCALRecoUtils.cxx:1077
 AliEMCALRecoUtils.cxx:1078
 AliEMCALRecoUtils.cxx:1079
 AliEMCALRecoUtils.cxx:1080
 AliEMCALRecoUtils.cxx:1081
 AliEMCALRecoUtils.cxx:1082
 AliEMCALRecoUtils.cxx:1083
 AliEMCALRecoUtils.cxx:1084
 AliEMCALRecoUtils.cxx:1085
 AliEMCALRecoUtils.cxx:1086
 AliEMCALRecoUtils.cxx:1087
 AliEMCALRecoUtils.cxx:1088
 AliEMCALRecoUtils.cxx:1089
 AliEMCALRecoUtils.cxx:1090
 AliEMCALRecoUtils.cxx:1091
 AliEMCALRecoUtils.cxx:1092
 AliEMCALRecoUtils.cxx:1093
 AliEMCALRecoUtils.cxx:1094
 AliEMCALRecoUtils.cxx:1095
 AliEMCALRecoUtils.cxx:1096
 AliEMCALRecoUtils.cxx:1097
 AliEMCALRecoUtils.cxx:1098
 AliEMCALRecoUtils.cxx:1099
 AliEMCALRecoUtils.cxx:1100
 AliEMCALRecoUtils.cxx:1101
 AliEMCALRecoUtils.cxx:1102
 AliEMCALRecoUtils.cxx:1103
 AliEMCALRecoUtils.cxx:1104
 AliEMCALRecoUtils.cxx:1105
 AliEMCALRecoUtils.cxx:1106
 AliEMCALRecoUtils.cxx:1107
 AliEMCALRecoUtils.cxx:1108
 AliEMCALRecoUtils.cxx:1109
 AliEMCALRecoUtils.cxx:1110
 AliEMCALRecoUtils.cxx:1111
 AliEMCALRecoUtils.cxx:1112
 AliEMCALRecoUtils.cxx:1113
 AliEMCALRecoUtils.cxx:1114
 AliEMCALRecoUtils.cxx:1115
 AliEMCALRecoUtils.cxx:1116
 AliEMCALRecoUtils.cxx:1117
 AliEMCALRecoUtils.cxx:1118
 AliEMCALRecoUtils.cxx:1119
 AliEMCALRecoUtils.cxx:1120
 AliEMCALRecoUtils.cxx:1121
 AliEMCALRecoUtils.cxx:1122
 AliEMCALRecoUtils.cxx:1123
 AliEMCALRecoUtils.cxx:1124
 AliEMCALRecoUtils.cxx:1125
 AliEMCALRecoUtils.cxx:1126
 AliEMCALRecoUtils.cxx:1127
 AliEMCALRecoUtils.cxx:1128
 AliEMCALRecoUtils.cxx:1129
 AliEMCALRecoUtils.cxx:1130
 AliEMCALRecoUtils.cxx:1131
 AliEMCALRecoUtils.cxx:1132
 AliEMCALRecoUtils.cxx:1133
 AliEMCALRecoUtils.cxx:1134
 AliEMCALRecoUtils.cxx:1135
 AliEMCALRecoUtils.cxx:1136
 AliEMCALRecoUtils.cxx:1137
 AliEMCALRecoUtils.cxx:1138
 AliEMCALRecoUtils.cxx:1139
 AliEMCALRecoUtils.cxx:1140
 AliEMCALRecoUtils.cxx:1141
 AliEMCALRecoUtils.cxx:1142
 AliEMCALRecoUtils.cxx:1143
 AliEMCALRecoUtils.cxx:1144
 AliEMCALRecoUtils.cxx:1145
 AliEMCALRecoUtils.cxx:1146
 AliEMCALRecoUtils.cxx:1147
 AliEMCALRecoUtils.cxx:1148
 AliEMCALRecoUtils.cxx:1149
 AliEMCALRecoUtils.cxx:1150
 AliEMCALRecoUtils.cxx:1151
 AliEMCALRecoUtils.cxx:1152
 AliEMCALRecoUtils.cxx:1153
 AliEMCALRecoUtils.cxx:1154
 AliEMCALRecoUtils.cxx:1155
 AliEMCALRecoUtils.cxx:1156
 AliEMCALRecoUtils.cxx:1157
 AliEMCALRecoUtils.cxx:1158
 AliEMCALRecoUtils.cxx:1159
 AliEMCALRecoUtils.cxx:1160
 AliEMCALRecoUtils.cxx:1161
 AliEMCALRecoUtils.cxx:1162
 AliEMCALRecoUtils.cxx:1163
 AliEMCALRecoUtils.cxx:1164
 AliEMCALRecoUtils.cxx:1165
 AliEMCALRecoUtils.cxx:1166
 AliEMCALRecoUtils.cxx:1167
 AliEMCALRecoUtils.cxx:1168
 AliEMCALRecoUtils.cxx:1169
 AliEMCALRecoUtils.cxx:1170
 AliEMCALRecoUtils.cxx:1171
 AliEMCALRecoUtils.cxx:1172
 AliEMCALRecoUtils.cxx:1173
 AliEMCALRecoUtils.cxx:1174
 AliEMCALRecoUtils.cxx:1175
 AliEMCALRecoUtils.cxx:1176
 AliEMCALRecoUtils.cxx:1177
 AliEMCALRecoUtils.cxx:1178
 AliEMCALRecoUtils.cxx:1179
 AliEMCALRecoUtils.cxx:1180
 AliEMCALRecoUtils.cxx:1181
 AliEMCALRecoUtils.cxx:1182
 AliEMCALRecoUtils.cxx:1183
 AliEMCALRecoUtils.cxx:1184
 AliEMCALRecoUtils.cxx:1185
 AliEMCALRecoUtils.cxx:1186
 AliEMCALRecoUtils.cxx:1187
 AliEMCALRecoUtils.cxx:1188
 AliEMCALRecoUtils.cxx:1189
 AliEMCALRecoUtils.cxx:1190
 AliEMCALRecoUtils.cxx:1191
 AliEMCALRecoUtils.cxx:1192
 AliEMCALRecoUtils.cxx:1193
 AliEMCALRecoUtils.cxx:1194
 AliEMCALRecoUtils.cxx:1195
 AliEMCALRecoUtils.cxx:1196
 AliEMCALRecoUtils.cxx:1197
 AliEMCALRecoUtils.cxx:1198
 AliEMCALRecoUtils.cxx:1199
 AliEMCALRecoUtils.cxx:1200
 AliEMCALRecoUtils.cxx:1201
 AliEMCALRecoUtils.cxx:1202
 AliEMCALRecoUtils.cxx:1203
 AliEMCALRecoUtils.cxx:1204
 AliEMCALRecoUtils.cxx:1205
 AliEMCALRecoUtils.cxx:1206
 AliEMCALRecoUtils.cxx:1207
 AliEMCALRecoUtils.cxx:1208
 AliEMCALRecoUtils.cxx:1209
 AliEMCALRecoUtils.cxx:1210
 AliEMCALRecoUtils.cxx:1211
 AliEMCALRecoUtils.cxx:1212
 AliEMCALRecoUtils.cxx:1213
 AliEMCALRecoUtils.cxx:1214
 AliEMCALRecoUtils.cxx:1215
 AliEMCALRecoUtils.cxx:1216
 AliEMCALRecoUtils.cxx:1217
 AliEMCALRecoUtils.cxx:1218
 AliEMCALRecoUtils.cxx:1219
 AliEMCALRecoUtils.cxx:1220
 AliEMCALRecoUtils.cxx:1221
 AliEMCALRecoUtils.cxx:1222
 AliEMCALRecoUtils.cxx:1223
 AliEMCALRecoUtils.cxx:1224
 AliEMCALRecoUtils.cxx:1225
 AliEMCALRecoUtils.cxx:1226
 AliEMCALRecoUtils.cxx:1227
 AliEMCALRecoUtils.cxx:1228
 AliEMCALRecoUtils.cxx:1229
 AliEMCALRecoUtils.cxx:1230
 AliEMCALRecoUtils.cxx:1231
 AliEMCALRecoUtils.cxx:1232
 AliEMCALRecoUtils.cxx:1233
 AliEMCALRecoUtils.cxx:1234
 AliEMCALRecoUtils.cxx:1235
 AliEMCALRecoUtils.cxx:1236
 AliEMCALRecoUtils.cxx:1237
 AliEMCALRecoUtils.cxx:1238
 AliEMCALRecoUtils.cxx:1239
 AliEMCALRecoUtils.cxx:1240
 AliEMCALRecoUtils.cxx:1241
 AliEMCALRecoUtils.cxx:1242
 AliEMCALRecoUtils.cxx:1243
 AliEMCALRecoUtils.cxx:1244
 AliEMCALRecoUtils.cxx:1245
 AliEMCALRecoUtils.cxx:1246
 AliEMCALRecoUtils.cxx:1247
 AliEMCALRecoUtils.cxx:1248
 AliEMCALRecoUtils.cxx:1249
 AliEMCALRecoUtils.cxx:1250
 AliEMCALRecoUtils.cxx:1251
 AliEMCALRecoUtils.cxx:1252
 AliEMCALRecoUtils.cxx:1253
 AliEMCALRecoUtils.cxx:1254
 AliEMCALRecoUtils.cxx:1255
 AliEMCALRecoUtils.cxx:1256
 AliEMCALRecoUtils.cxx:1257
 AliEMCALRecoUtils.cxx:1258
 AliEMCALRecoUtils.cxx:1259
 AliEMCALRecoUtils.cxx:1260
 AliEMCALRecoUtils.cxx:1261
 AliEMCALRecoUtils.cxx:1262
 AliEMCALRecoUtils.cxx:1263
 AliEMCALRecoUtils.cxx:1264
 AliEMCALRecoUtils.cxx:1265
 AliEMCALRecoUtils.cxx:1266
 AliEMCALRecoUtils.cxx:1267
 AliEMCALRecoUtils.cxx:1268
 AliEMCALRecoUtils.cxx:1269
 AliEMCALRecoUtils.cxx:1270
 AliEMCALRecoUtils.cxx:1271
 AliEMCALRecoUtils.cxx:1272
 AliEMCALRecoUtils.cxx:1273
 AliEMCALRecoUtils.cxx:1274
 AliEMCALRecoUtils.cxx:1275
 AliEMCALRecoUtils.cxx:1276
 AliEMCALRecoUtils.cxx:1277
 AliEMCALRecoUtils.cxx:1278
 AliEMCALRecoUtils.cxx:1279
 AliEMCALRecoUtils.cxx:1280
 AliEMCALRecoUtils.cxx:1281
 AliEMCALRecoUtils.cxx:1282
 AliEMCALRecoUtils.cxx:1283
 AliEMCALRecoUtils.cxx:1284
 AliEMCALRecoUtils.cxx:1285
 AliEMCALRecoUtils.cxx:1286
 AliEMCALRecoUtils.cxx:1287
 AliEMCALRecoUtils.cxx:1288
 AliEMCALRecoUtils.cxx:1289
 AliEMCALRecoUtils.cxx:1290
 AliEMCALRecoUtils.cxx:1291
 AliEMCALRecoUtils.cxx:1292
 AliEMCALRecoUtils.cxx:1293
 AliEMCALRecoUtils.cxx:1294
 AliEMCALRecoUtils.cxx:1295
 AliEMCALRecoUtils.cxx:1296
 AliEMCALRecoUtils.cxx:1297
 AliEMCALRecoUtils.cxx:1298
 AliEMCALRecoUtils.cxx:1299
 AliEMCALRecoUtils.cxx:1300
 AliEMCALRecoUtils.cxx:1301
 AliEMCALRecoUtils.cxx:1302
 AliEMCALRecoUtils.cxx:1303
 AliEMCALRecoUtils.cxx:1304
 AliEMCALRecoUtils.cxx:1305
 AliEMCALRecoUtils.cxx:1306
 AliEMCALRecoUtils.cxx:1307
 AliEMCALRecoUtils.cxx:1308
 AliEMCALRecoUtils.cxx:1309
 AliEMCALRecoUtils.cxx:1310
 AliEMCALRecoUtils.cxx:1311
 AliEMCALRecoUtils.cxx:1312
 AliEMCALRecoUtils.cxx:1313
 AliEMCALRecoUtils.cxx:1314
 AliEMCALRecoUtils.cxx:1315
 AliEMCALRecoUtils.cxx:1316
 AliEMCALRecoUtils.cxx:1317
 AliEMCALRecoUtils.cxx:1318
 AliEMCALRecoUtils.cxx:1319
 AliEMCALRecoUtils.cxx:1320
 AliEMCALRecoUtils.cxx:1321
 AliEMCALRecoUtils.cxx:1322
 AliEMCALRecoUtils.cxx:1323
 AliEMCALRecoUtils.cxx:1324
 AliEMCALRecoUtils.cxx:1325
 AliEMCALRecoUtils.cxx:1326
 AliEMCALRecoUtils.cxx:1327
 AliEMCALRecoUtils.cxx:1328
 AliEMCALRecoUtils.cxx:1329
 AliEMCALRecoUtils.cxx:1330
 AliEMCALRecoUtils.cxx:1331
 AliEMCALRecoUtils.cxx:1332
 AliEMCALRecoUtils.cxx:1333
 AliEMCALRecoUtils.cxx:1334
 AliEMCALRecoUtils.cxx:1335
 AliEMCALRecoUtils.cxx:1336
 AliEMCALRecoUtils.cxx:1337
 AliEMCALRecoUtils.cxx:1338
 AliEMCALRecoUtils.cxx:1339
 AliEMCALRecoUtils.cxx:1340
 AliEMCALRecoUtils.cxx:1341
 AliEMCALRecoUtils.cxx:1342
 AliEMCALRecoUtils.cxx:1343
 AliEMCALRecoUtils.cxx:1344
 AliEMCALRecoUtils.cxx:1345
 AliEMCALRecoUtils.cxx:1346
 AliEMCALRecoUtils.cxx:1347
 AliEMCALRecoUtils.cxx:1348
 AliEMCALRecoUtils.cxx:1349
 AliEMCALRecoUtils.cxx:1350
 AliEMCALRecoUtils.cxx:1351
 AliEMCALRecoUtils.cxx:1352
 AliEMCALRecoUtils.cxx:1353
 AliEMCALRecoUtils.cxx:1354
 AliEMCALRecoUtils.cxx:1355
 AliEMCALRecoUtils.cxx:1356
 AliEMCALRecoUtils.cxx:1357
 AliEMCALRecoUtils.cxx:1358
 AliEMCALRecoUtils.cxx:1359
 AliEMCALRecoUtils.cxx:1360
 AliEMCALRecoUtils.cxx:1361
 AliEMCALRecoUtils.cxx:1362
 AliEMCALRecoUtils.cxx:1363
 AliEMCALRecoUtils.cxx:1364
 AliEMCALRecoUtils.cxx:1365
 AliEMCALRecoUtils.cxx:1366
 AliEMCALRecoUtils.cxx:1367
 AliEMCALRecoUtils.cxx:1368
 AliEMCALRecoUtils.cxx:1369
 AliEMCALRecoUtils.cxx:1370
 AliEMCALRecoUtils.cxx:1371
 AliEMCALRecoUtils.cxx:1372
 AliEMCALRecoUtils.cxx:1373
 AliEMCALRecoUtils.cxx:1374
 AliEMCALRecoUtils.cxx:1375
 AliEMCALRecoUtils.cxx:1376
 AliEMCALRecoUtils.cxx:1377
 AliEMCALRecoUtils.cxx:1378
 AliEMCALRecoUtils.cxx:1379
 AliEMCALRecoUtils.cxx:1380
 AliEMCALRecoUtils.cxx:1381
 AliEMCALRecoUtils.cxx:1382
 AliEMCALRecoUtils.cxx:1383
 AliEMCALRecoUtils.cxx:1384
 AliEMCALRecoUtils.cxx:1385
 AliEMCALRecoUtils.cxx:1386
 AliEMCALRecoUtils.cxx:1387
 AliEMCALRecoUtils.cxx:1388
 AliEMCALRecoUtils.cxx:1389
 AliEMCALRecoUtils.cxx:1390
 AliEMCALRecoUtils.cxx:1391
 AliEMCALRecoUtils.cxx:1392
 AliEMCALRecoUtils.cxx:1393
 AliEMCALRecoUtils.cxx:1394
 AliEMCALRecoUtils.cxx:1395
 AliEMCALRecoUtils.cxx:1396
 AliEMCALRecoUtils.cxx:1397
 AliEMCALRecoUtils.cxx:1398
 AliEMCALRecoUtils.cxx:1399
 AliEMCALRecoUtils.cxx:1400
 AliEMCALRecoUtils.cxx:1401
 AliEMCALRecoUtils.cxx:1402
 AliEMCALRecoUtils.cxx:1403
 AliEMCALRecoUtils.cxx:1404
 AliEMCALRecoUtils.cxx:1405
 AliEMCALRecoUtils.cxx:1406
 AliEMCALRecoUtils.cxx:1407
 AliEMCALRecoUtils.cxx:1408
 AliEMCALRecoUtils.cxx:1409
 AliEMCALRecoUtils.cxx:1410
 AliEMCALRecoUtils.cxx:1411
 AliEMCALRecoUtils.cxx:1412
 AliEMCALRecoUtils.cxx:1413
 AliEMCALRecoUtils.cxx:1414
 AliEMCALRecoUtils.cxx:1415
 AliEMCALRecoUtils.cxx:1416
 AliEMCALRecoUtils.cxx:1417
 AliEMCALRecoUtils.cxx:1418
 AliEMCALRecoUtils.cxx:1419
 AliEMCALRecoUtils.cxx:1420
 AliEMCALRecoUtils.cxx:1421
 AliEMCALRecoUtils.cxx:1422
 AliEMCALRecoUtils.cxx:1423
 AliEMCALRecoUtils.cxx:1424
 AliEMCALRecoUtils.cxx:1425
 AliEMCALRecoUtils.cxx:1426
 AliEMCALRecoUtils.cxx:1427
 AliEMCALRecoUtils.cxx:1428
 AliEMCALRecoUtils.cxx:1429
 AliEMCALRecoUtils.cxx:1430
 AliEMCALRecoUtils.cxx:1431
 AliEMCALRecoUtils.cxx:1432
 AliEMCALRecoUtils.cxx:1433
 AliEMCALRecoUtils.cxx:1434
 AliEMCALRecoUtils.cxx:1435
 AliEMCALRecoUtils.cxx:1436
 AliEMCALRecoUtils.cxx:1437
 AliEMCALRecoUtils.cxx:1438
 AliEMCALRecoUtils.cxx:1439
 AliEMCALRecoUtils.cxx:1440
 AliEMCALRecoUtils.cxx:1441
 AliEMCALRecoUtils.cxx:1442
 AliEMCALRecoUtils.cxx:1443
 AliEMCALRecoUtils.cxx:1444
 AliEMCALRecoUtils.cxx:1445
 AliEMCALRecoUtils.cxx:1446
 AliEMCALRecoUtils.cxx:1447
 AliEMCALRecoUtils.cxx:1448
 AliEMCALRecoUtils.cxx:1449
 AliEMCALRecoUtils.cxx:1450
 AliEMCALRecoUtils.cxx:1451
 AliEMCALRecoUtils.cxx:1452
 AliEMCALRecoUtils.cxx:1453
 AliEMCALRecoUtils.cxx:1454
 AliEMCALRecoUtils.cxx:1455
 AliEMCALRecoUtils.cxx:1456
 AliEMCALRecoUtils.cxx:1457
 AliEMCALRecoUtils.cxx:1458
 AliEMCALRecoUtils.cxx:1459
 AliEMCALRecoUtils.cxx:1460
 AliEMCALRecoUtils.cxx:1461
 AliEMCALRecoUtils.cxx:1462
 AliEMCALRecoUtils.cxx:1463
 AliEMCALRecoUtils.cxx:1464
 AliEMCALRecoUtils.cxx:1465
 AliEMCALRecoUtils.cxx:1466
 AliEMCALRecoUtils.cxx:1467
 AliEMCALRecoUtils.cxx:1468
 AliEMCALRecoUtils.cxx:1469
 AliEMCALRecoUtils.cxx:1470
 AliEMCALRecoUtils.cxx:1471
 AliEMCALRecoUtils.cxx:1472
 AliEMCALRecoUtils.cxx:1473
 AliEMCALRecoUtils.cxx:1474
 AliEMCALRecoUtils.cxx:1475
 AliEMCALRecoUtils.cxx:1476
 AliEMCALRecoUtils.cxx:1477
 AliEMCALRecoUtils.cxx:1478
 AliEMCALRecoUtils.cxx:1479
 AliEMCALRecoUtils.cxx:1480
 AliEMCALRecoUtils.cxx:1481
 AliEMCALRecoUtils.cxx:1482
 AliEMCALRecoUtils.cxx:1483
 AliEMCALRecoUtils.cxx:1484
 AliEMCALRecoUtils.cxx:1485
 AliEMCALRecoUtils.cxx:1486
 AliEMCALRecoUtils.cxx:1487
 AliEMCALRecoUtils.cxx:1488
 AliEMCALRecoUtils.cxx:1489
 AliEMCALRecoUtils.cxx:1490
 AliEMCALRecoUtils.cxx:1491
 AliEMCALRecoUtils.cxx:1492
 AliEMCALRecoUtils.cxx:1493
 AliEMCALRecoUtils.cxx:1494
 AliEMCALRecoUtils.cxx:1495
 AliEMCALRecoUtils.cxx:1496
 AliEMCALRecoUtils.cxx:1497
 AliEMCALRecoUtils.cxx:1498
 AliEMCALRecoUtils.cxx:1499
 AliEMCALRecoUtils.cxx:1500
 AliEMCALRecoUtils.cxx:1501
 AliEMCALRecoUtils.cxx:1502
 AliEMCALRecoUtils.cxx:1503
 AliEMCALRecoUtils.cxx:1504
 AliEMCALRecoUtils.cxx:1505
 AliEMCALRecoUtils.cxx:1506
 AliEMCALRecoUtils.cxx:1507
 AliEMCALRecoUtils.cxx:1508
 AliEMCALRecoUtils.cxx:1509
 AliEMCALRecoUtils.cxx:1510
 AliEMCALRecoUtils.cxx:1511
 AliEMCALRecoUtils.cxx:1512
 AliEMCALRecoUtils.cxx:1513
 AliEMCALRecoUtils.cxx:1514
 AliEMCALRecoUtils.cxx:1515
 AliEMCALRecoUtils.cxx:1516
 AliEMCALRecoUtils.cxx:1517
 AliEMCALRecoUtils.cxx:1518
 AliEMCALRecoUtils.cxx:1519
 AliEMCALRecoUtils.cxx:1520
 AliEMCALRecoUtils.cxx:1521
 AliEMCALRecoUtils.cxx:1522
 AliEMCALRecoUtils.cxx:1523
 AliEMCALRecoUtils.cxx:1524
 AliEMCALRecoUtils.cxx:1525
 AliEMCALRecoUtils.cxx:1526
 AliEMCALRecoUtils.cxx:1527
 AliEMCALRecoUtils.cxx:1528
 AliEMCALRecoUtils.cxx:1529
 AliEMCALRecoUtils.cxx:1530
 AliEMCALRecoUtils.cxx:1531
 AliEMCALRecoUtils.cxx:1532
 AliEMCALRecoUtils.cxx:1533
 AliEMCALRecoUtils.cxx:1534
 AliEMCALRecoUtils.cxx:1535
 AliEMCALRecoUtils.cxx:1536
 AliEMCALRecoUtils.cxx:1537
 AliEMCALRecoUtils.cxx:1538
 AliEMCALRecoUtils.cxx:1539
 AliEMCALRecoUtils.cxx:1540
 AliEMCALRecoUtils.cxx:1541
 AliEMCALRecoUtils.cxx:1542
 AliEMCALRecoUtils.cxx:1543
 AliEMCALRecoUtils.cxx:1544
 AliEMCALRecoUtils.cxx:1545
 AliEMCALRecoUtils.cxx:1546
 AliEMCALRecoUtils.cxx:1547
 AliEMCALRecoUtils.cxx:1548
 AliEMCALRecoUtils.cxx:1549
 AliEMCALRecoUtils.cxx:1550
 AliEMCALRecoUtils.cxx:1551
 AliEMCALRecoUtils.cxx:1552
 AliEMCALRecoUtils.cxx:1553
 AliEMCALRecoUtils.cxx:1554
 AliEMCALRecoUtils.cxx:1555
 AliEMCALRecoUtils.cxx:1556
 AliEMCALRecoUtils.cxx:1557
 AliEMCALRecoUtils.cxx:1558
 AliEMCALRecoUtils.cxx:1559
 AliEMCALRecoUtils.cxx:1560
 AliEMCALRecoUtils.cxx:1561
 AliEMCALRecoUtils.cxx:1562
 AliEMCALRecoUtils.cxx:1563
 AliEMCALRecoUtils.cxx:1564
 AliEMCALRecoUtils.cxx:1565
 AliEMCALRecoUtils.cxx:1566
 AliEMCALRecoUtils.cxx:1567
 AliEMCALRecoUtils.cxx:1568
 AliEMCALRecoUtils.cxx:1569
 AliEMCALRecoUtils.cxx:1570
 AliEMCALRecoUtils.cxx:1571
 AliEMCALRecoUtils.cxx:1572
 AliEMCALRecoUtils.cxx:1573
 AliEMCALRecoUtils.cxx:1574
 AliEMCALRecoUtils.cxx:1575
 AliEMCALRecoUtils.cxx:1576
 AliEMCALRecoUtils.cxx:1577
 AliEMCALRecoUtils.cxx:1578
 AliEMCALRecoUtils.cxx:1579
 AliEMCALRecoUtils.cxx:1580
 AliEMCALRecoUtils.cxx:1581
 AliEMCALRecoUtils.cxx:1582
 AliEMCALRecoUtils.cxx:1583
 AliEMCALRecoUtils.cxx:1584
 AliEMCALRecoUtils.cxx:1585
 AliEMCALRecoUtils.cxx:1586
 AliEMCALRecoUtils.cxx:1587
 AliEMCALRecoUtils.cxx:1588
 AliEMCALRecoUtils.cxx:1589
 AliEMCALRecoUtils.cxx:1590
 AliEMCALRecoUtils.cxx:1591
 AliEMCALRecoUtils.cxx:1592
 AliEMCALRecoUtils.cxx:1593
 AliEMCALRecoUtils.cxx:1594
 AliEMCALRecoUtils.cxx:1595
 AliEMCALRecoUtils.cxx:1596
 AliEMCALRecoUtils.cxx:1597
 AliEMCALRecoUtils.cxx:1598
 AliEMCALRecoUtils.cxx:1599
 AliEMCALRecoUtils.cxx:1600
 AliEMCALRecoUtils.cxx:1601
 AliEMCALRecoUtils.cxx:1602
 AliEMCALRecoUtils.cxx:1603
 AliEMCALRecoUtils.cxx:1604
 AliEMCALRecoUtils.cxx:1605
 AliEMCALRecoUtils.cxx:1606
 AliEMCALRecoUtils.cxx:1607
 AliEMCALRecoUtils.cxx:1608
 AliEMCALRecoUtils.cxx:1609
 AliEMCALRecoUtils.cxx:1610
 AliEMCALRecoUtils.cxx:1611
 AliEMCALRecoUtils.cxx:1612
 AliEMCALRecoUtils.cxx:1613
 AliEMCALRecoUtils.cxx:1614
 AliEMCALRecoUtils.cxx:1615
 AliEMCALRecoUtils.cxx:1616
 AliEMCALRecoUtils.cxx:1617
 AliEMCALRecoUtils.cxx:1618
 AliEMCALRecoUtils.cxx:1619
 AliEMCALRecoUtils.cxx:1620
 AliEMCALRecoUtils.cxx:1621
 AliEMCALRecoUtils.cxx:1622
 AliEMCALRecoUtils.cxx:1623
 AliEMCALRecoUtils.cxx:1624
 AliEMCALRecoUtils.cxx:1625
 AliEMCALRecoUtils.cxx:1626
 AliEMCALRecoUtils.cxx:1627
 AliEMCALRecoUtils.cxx:1628
 AliEMCALRecoUtils.cxx:1629
 AliEMCALRecoUtils.cxx:1630
 AliEMCALRecoUtils.cxx:1631
 AliEMCALRecoUtils.cxx:1632
 AliEMCALRecoUtils.cxx:1633
 AliEMCALRecoUtils.cxx:1634
 AliEMCALRecoUtils.cxx:1635
 AliEMCALRecoUtils.cxx:1636
 AliEMCALRecoUtils.cxx:1637
 AliEMCALRecoUtils.cxx:1638
 AliEMCALRecoUtils.cxx:1639
 AliEMCALRecoUtils.cxx:1640
 AliEMCALRecoUtils.cxx:1641
 AliEMCALRecoUtils.cxx:1642
 AliEMCALRecoUtils.cxx:1643
 AliEMCALRecoUtils.cxx:1644
 AliEMCALRecoUtils.cxx:1645
 AliEMCALRecoUtils.cxx:1646
 AliEMCALRecoUtils.cxx:1647
 AliEMCALRecoUtils.cxx:1648
 AliEMCALRecoUtils.cxx:1649
 AliEMCALRecoUtils.cxx:1650
 AliEMCALRecoUtils.cxx:1651
 AliEMCALRecoUtils.cxx:1652
 AliEMCALRecoUtils.cxx:1653
 AliEMCALRecoUtils.cxx:1654
 AliEMCALRecoUtils.cxx:1655
 AliEMCALRecoUtils.cxx:1656
 AliEMCALRecoUtils.cxx:1657
 AliEMCALRecoUtils.cxx:1658
 AliEMCALRecoUtils.cxx:1659
 AliEMCALRecoUtils.cxx:1660
 AliEMCALRecoUtils.cxx:1661
 AliEMCALRecoUtils.cxx:1662
 AliEMCALRecoUtils.cxx:1663
 AliEMCALRecoUtils.cxx:1664
 AliEMCALRecoUtils.cxx:1665
 AliEMCALRecoUtils.cxx:1666
 AliEMCALRecoUtils.cxx:1667
 AliEMCALRecoUtils.cxx:1668
 AliEMCALRecoUtils.cxx:1669
 AliEMCALRecoUtils.cxx:1670
 AliEMCALRecoUtils.cxx:1671
 AliEMCALRecoUtils.cxx:1672
 AliEMCALRecoUtils.cxx:1673
 AliEMCALRecoUtils.cxx:1674
 AliEMCALRecoUtils.cxx:1675
 AliEMCALRecoUtils.cxx:1676
 AliEMCALRecoUtils.cxx:1677
 AliEMCALRecoUtils.cxx:1678
 AliEMCALRecoUtils.cxx:1679
 AliEMCALRecoUtils.cxx:1680
 AliEMCALRecoUtils.cxx:1681
 AliEMCALRecoUtils.cxx:1682
 AliEMCALRecoUtils.cxx:1683
 AliEMCALRecoUtils.cxx:1684
 AliEMCALRecoUtils.cxx:1685
 AliEMCALRecoUtils.cxx:1686
 AliEMCALRecoUtils.cxx:1687
 AliEMCALRecoUtils.cxx:1688
 AliEMCALRecoUtils.cxx:1689
 AliEMCALRecoUtils.cxx:1690
 AliEMCALRecoUtils.cxx:1691
 AliEMCALRecoUtils.cxx:1692
 AliEMCALRecoUtils.cxx:1693
 AliEMCALRecoUtils.cxx:1694
 AliEMCALRecoUtils.cxx:1695
 AliEMCALRecoUtils.cxx:1696
 AliEMCALRecoUtils.cxx:1697
 AliEMCALRecoUtils.cxx:1698
 AliEMCALRecoUtils.cxx:1699
 AliEMCALRecoUtils.cxx:1700
 AliEMCALRecoUtils.cxx:1701
 AliEMCALRecoUtils.cxx:1702
 AliEMCALRecoUtils.cxx:1703
 AliEMCALRecoUtils.cxx:1704
 AliEMCALRecoUtils.cxx:1705
 AliEMCALRecoUtils.cxx:1706
 AliEMCALRecoUtils.cxx:1707
 AliEMCALRecoUtils.cxx:1708
 AliEMCALRecoUtils.cxx:1709
 AliEMCALRecoUtils.cxx:1710
 AliEMCALRecoUtils.cxx:1711
 AliEMCALRecoUtils.cxx:1712
 AliEMCALRecoUtils.cxx:1713
 AliEMCALRecoUtils.cxx:1714
 AliEMCALRecoUtils.cxx:1715
 AliEMCALRecoUtils.cxx:1716
 AliEMCALRecoUtils.cxx:1717
 AliEMCALRecoUtils.cxx:1718
 AliEMCALRecoUtils.cxx:1719
 AliEMCALRecoUtils.cxx:1720
 AliEMCALRecoUtils.cxx:1721
 AliEMCALRecoUtils.cxx:1722
 AliEMCALRecoUtils.cxx:1723
 AliEMCALRecoUtils.cxx:1724
 AliEMCALRecoUtils.cxx:1725
 AliEMCALRecoUtils.cxx:1726
 AliEMCALRecoUtils.cxx:1727
 AliEMCALRecoUtils.cxx:1728
 AliEMCALRecoUtils.cxx:1729
 AliEMCALRecoUtils.cxx:1730
 AliEMCALRecoUtils.cxx:1731
 AliEMCALRecoUtils.cxx:1732
 AliEMCALRecoUtils.cxx:1733
 AliEMCALRecoUtils.cxx:1734
 AliEMCALRecoUtils.cxx:1735
 AliEMCALRecoUtils.cxx:1736
 AliEMCALRecoUtils.cxx:1737
 AliEMCALRecoUtils.cxx:1738
 AliEMCALRecoUtils.cxx:1739
 AliEMCALRecoUtils.cxx:1740
 AliEMCALRecoUtils.cxx:1741
 AliEMCALRecoUtils.cxx:1742
 AliEMCALRecoUtils.cxx:1743
 AliEMCALRecoUtils.cxx:1744
 AliEMCALRecoUtils.cxx:1745
 AliEMCALRecoUtils.cxx:1746
 AliEMCALRecoUtils.cxx:1747
 AliEMCALRecoUtils.cxx:1748
 AliEMCALRecoUtils.cxx:1749
 AliEMCALRecoUtils.cxx:1750
 AliEMCALRecoUtils.cxx:1751
 AliEMCALRecoUtils.cxx:1752
 AliEMCALRecoUtils.cxx:1753
 AliEMCALRecoUtils.cxx:1754
 AliEMCALRecoUtils.cxx:1755
 AliEMCALRecoUtils.cxx:1756
 AliEMCALRecoUtils.cxx:1757
 AliEMCALRecoUtils.cxx:1758
 AliEMCALRecoUtils.cxx:1759
 AliEMCALRecoUtils.cxx:1760
 AliEMCALRecoUtils.cxx:1761
 AliEMCALRecoUtils.cxx:1762
 AliEMCALRecoUtils.cxx:1763
 AliEMCALRecoUtils.cxx:1764
 AliEMCALRecoUtils.cxx:1765
 AliEMCALRecoUtils.cxx:1766
 AliEMCALRecoUtils.cxx:1767
 AliEMCALRecoUtils.cxx:1768
 AliEMCALRecoUtils.cxx:1769
 AliEMCALRecoUtils.cxx:1770
 AliEMCALRecoUtils.cxx:1771
 AliEMCALRecoUtils.cxx:1772
 AliEMCALRecoUtils.cxx:1773
 AliEMCALRecoUtils.cxx:1774
 AliEMCALRecoUtils.cxx:1775
 AliEMCALRecoUtils.cxx:1776
 AliEMCALRecoUtils.cxx:1777
 AliEMCALRecoUtils.cxx:1778
 AliEMCALRecoUtils.cxx:1779
 AliEMCALRecoUtils.cxx:1780
 AliEMCALRecoUtils.cxx:1781
 AliEMCALRecoUtils.cxx:1782
 AliEMCALRecoUtils.cxx:1783
 AliEMCALRecoUtils.cxx:1784
 AliEMCALRecoUtils.cxx:1785
 AliEMCALRecoUtils.cxx:1786
 AliEMCALRecoUtils.cxx:1787
 AliEMCALRecoUtils.cxx:1788
 AliEMCALRecoUtils.cxx:1789
 AliEMCALRecoUtils.cxx:1790
 AliEMCALRecoUtils.cxx:1791
 AliEMCALRecoUtils.cxx:1792
 AliEMCALRecoUtils.cxx:1793
 AliEMCALRecoUtils.cxx:1794
 AliEMCALRecoUtils.cxx:1795
 AliEMCALRecoUtils.cxx:1796
 AliEMCALRecoUtils.cxx:1797
 AliEMCALRecoUtils.cxx:1798
 AliEMCALRecoUtils.cxx:1799
 AliEMCALRecoUtils.cxx:1800
 AliEMCALRecoUtils.cxx:1801
 AliEMCALRecoUtils.cxx:1802
 AliEMCALRecoUtils.cxx:1803
 AliEMCALRecoUtils.cxx:1804
 AliEMCALRecoUtils.cxx:1805
 AliEMCALRecoUtils.cxx:1806
 AliEMCALRecoUtils.cxx:1807
 AliEMCALRecoUtils.cxx:1808
 AliEMCALRecoUtils.cxx:1809
 AliEMCALRecoUtils.cxx:1810
 AliEMCALRecoUtils.cxx:1811
 AliEMCALRecoUtils.cxx:1812
 AliEMCALRecoUtils.cxx:1813
 AliEMCALRecoUtils.cxx:1814
 AliEMCALRecoUtils.cxx:1815
 AliEMCALRecoUtils.cxx:1816
 AliEMCALRecoUtils.cxx:1817
 AliEMCALRecoUtils.cxx:1818
 AliEMCALRecoUtils.cxx:1819
 AliEMCALRecoUtils.cxx:1820
 AliEMCALRecoUtils.cxx:1821
 AliEMCALRecoUtils.cxx:1822
 AliEMCALRecoUtils.cxx:1823
 AliEMCALRecoUtils.cxx:1824
 AliEMCALRecoUtils.cxx:1825
 AliEMCALRecoUtils.cxx:1826
 AliEMCALRecoUtils.cxx:1827
 AliEMCALRecoUtils.cxx:1828
 AliEMCALRecoUtils.cxx:1829
 AliEMCALRecoUtils.cxx:1830
 AliEMCALRecoUtils.cxx:1831
 AliEMCALRecoUtils.cxx:1832
 AliEMCALRecoUtils.cxx:1833
 AliEMCALRecoUtils.cxx:1834
 AliEMCALRecoUtils.cxx:1835
 AliEMCALRecoUtils.cxx:1836
 AliEMCALRecoUtils.cxx:1837
 AliEMCALRecoUtils.cxx:1838
 AliEMCALRecoUtils.cxx:1839
 AliEMCALRecoUtils.cxx:1840
 AliEMCALRecoUtils.cxx:1841
 AliEMCALRecoUtils.cxx:1842
 AliEMCALRecoUtils.cxx:1843
 AliEMCALRecoUtils.cxx:1844
 AliEMCALRecoUtils.cxx:1845
 AliEMCALRecoUtils.cxx:1846
 AliEMCALRecoUtils.cxx:1847
 AliEMCALRecoUtils.cxx:1848
 AliEMCALRecoUtils.cxx:1849
 AliEMCALRecoUtils.cxx:1850
 AliEMCALRecoUtils.cxx:1851
 AliEMCALRecoUtils.cxx:1852
 AliEMCALRecoUtils.cxx:1853
 AliEMCALRecoUtils.cxx:1854
 AliEMCALRecoUtils.cxx:1855
 AliEMCALRecoUtils.cxx:1856
 AliEMCALRecoUtils.cxx:1857
 AliEMCALRecoUtils.cxx:1858
 AliEMCALRecoUtils.cxx:1859
 AliEMCALRecoUtils.cxx:1860
 AliEMCALRecoUtils.cxx:1861
 AliEMCALRecoUtils.cxx:1862
 AliEMCALRecoUtils.cxx:1863
 AliEMCALRecoUtils.cxx:1864
 AliEMCALRecoUtils.cxx:1865
 AliEMCALRecoUtils.cxx:1866
 AliEMCALRecoUtils.cxx:1867
 AliEMCALRecoUtils.cxx:1868
 AliEMCALRecoUtils.cxx:1869
 AliEMCALRecoUtils.cxx:1870
 AliEMCALRecoUtils.cxx:1871
 AliEMCALRecoUtils.cxx:1872
 AliEMCALRecoUtils.cxx:1873
 AliEMCALRecoUtils.cxx:1874
 AliEMCALRecoUtils.cxx:1875
 AliEMCALRecoUtils.cxx:1876
 AliEMCALRecoUtils.cxx:1877
 AliEMCALRecoUtils.cxx:1878
 AliEMCALRecoUtils.cxx:1879
 AliEMCALRecoUtils.cxx:1880
 AliEMCALRecoUtils.cxx:1881
 AliEMCALRecoUtils.cxx:1882
 AliEMCALRecoUtils.cxx:1883
 AliEMCALRecoUtils.cxx:1884
 AliEMCALRecoUtils.cxx:1885
 AliEMCALRecoUtils.cxx:1886
 AliEMCALRecoUtils.cxx:1887
 AliEMCALRecoUtils.cxx:1888
 AliEMCALRecoUtils.cxx:1889
 AliEMCALRecoUtils.cxx:1890
 AliEMCALRecoUtils.cxx:1891
 AliEMCALRecoUtils.cxx:1892
 AliEMCALRecoUtils.cxx:1893
 AliEMCALRecoUtils.cxx:1894
 AliEMCALRecoUtils.cxx:1895
 AliEMCALRecoUtils.cxx:1896
 AliEMCALRecoUtils.cxx:1897
 AliEMCALRecoUtils.cxx:1898
 AliEMCALRecoUtils.cxx:1899
 AliEMCALRecoUtils.cxx:1900
 AliEMCALRecoUtils.cxx:1901
 AliEMCALRecoUtils.cxx:1902
 AliEMCALRecoUtils.cxx:1903
 AliEMCALRecoUtils.cxx:1904
 AliEMCALRecoUtils.cxx:1905
 AliEMCALRecoUtils.cxx:1906
 AliEMCALRecoUtils.cxx:1907
 AliEMCALRecoUtils.cxx:1908
 AliEMCALRecoUtils.cxx:1909
 AliEMCALRecoUtils.cxx:1910
 AliEMCALRecoUtils.cxx:1911
 AliEMCALRecoUtils.cxx:1912
 AliEMCALRecoUtils.cxx:1913
 AliEMCALRecoUtils.cxx:1914
 AliEMCALRecoUtils.cxx:1915
 AliEMCALRecoUtils.cxx:1916
 AliEMCALRecoUtils.cxx:1917
 AliEMCALRecoUtils.cxx:1918
 AliEMCALRecoUtils.cxx:1919
 AliEMCALRecoUtils.cxx:1920
 AliEMCALRecoUtils.cxx:1921
 AliEMCALRecoUtils.cxx:1922
 AliEMCALRecoUtils.cxx:1923
 AliEMCALRecoUtils.cxx:1924
 AliEMCALRecoUtils.cxx:1925
 AliEMCALRecoUtils.cxx:1926
 AliEMCALRecoUtils.cxx:1927
 AliEMCALRecoUtils.cxx:1928
 AliEMCALRecoUtils.cxx:1929
 AliEMCALRecoUtils.cxx:1930
 AliEMCALRecoUtils.cxx:1931
 AliEMCALRecoUtils.cxx:1932
 AliEMCALRecoUtils.cxx:1933
 AliEMCALRecoUtils.cxx:1934
 AliEMCALRecoUtils.cxx:1935
 AliEMCALRecoUtils.cxx:1936
 AliEMCALRecoUtils.cxx:1937
 AliEMCALRecoUtils.cxx:1938
 AliEMCALRecoUtils.cxx:1939
 AliEMCALRecoUtils.cxx:1940
 AliEMCALRecoUtils.cxx:1941
 AliEMCALRecoUtils.cxx:1942
 AliEMCALRecoUtils.cxx:1943
 AliEMCALRecoUtils.cxx:1944
 AliEMCALRecoUtils.cxx:1945
 AliEMCALRecoUtils.cxx:1946
 AliEMCALRecoUtils.cxx:1947
 AliEMCALRecoUtils.cxx:1948
 AliEMCALRecoUtils.cxx:1949
 AliEMCALRecoUtils.cxx:1950
 AliEMCALRecoUtils.cxx:1951
 AliEMCALRecoUtils.cxx:1952
 AliEMCALRecoUtils.cxx:1953
 AliEMCALRecoUtils.cxx:1954
 AliEMCALRecoUtils.cxx:1955
 AliEMCALRecoUtils.cxx:1956
 AliEMCALRecoUtils.cxx:1957
 AliEMCALRecoUtils.cxx:1958
 AliEMCALRecoUtils.cxx:1959
 AliEMCALRecoUtils.cxx:1960
 AliEMCALRecoUtils.cxx:1961
 AliEMCALRecoUtils.cxx:1962
 AliEMCALRecoUtils.cxx:1963
 AliEMCALRecoUtils.cxx:1964
 AliEMCALRecoUtils.cxx:1965
 AliEMCALRecoUtils.cxx:1966
 AliEMCALRecoUtils.cxx:1967
 AliEMCALRecoUtils.cxx:1968
 AliEMCALRecoUtils.cxx:1969
 AliEMCALRecoUtils.cxx:1970
 AliEMCALRecoUtils.cxx:1971
 AliEMCALRecoUtils.cxx:1972
 AliEMCALRecoUtils.cxx:1973
 AliEMCALRecoUtils.cxx:1974
 AliEMCALRecoUtils.cxx:1975
 AliEMCALRecoUtils.cxx:1976
 AliEMCALRecoUtils.cxx:1977
 AliEMCALRecoUtils.cxx:1978
 AliEMCALRecoUtils.cxx:1979
 AliEMCALRecoUtils.cxx:1980
 AliEMCALRecoUtils.cxx:1981
 AliEMCALRecoUtils.cxx:1982
 AliEMCALRecoUtils.cxx:1983
 AliEMCALRecoUtils.cxx:1984
 AliEMCALRecoUtils.cxx:1985
 AliEMCALRecoUtils.cxx:1986
 AliEMCALRecoUtils.cxx:1987
 AliEMCALRecoUtils.cxx:1988
 AliEMCALRecoUtils.cxx:1989
 AliEMCALRecoUtils.cxx:1990
 AliEMCALRecoUtils.cxx:1991
 AliEMCALRecoUtils.cxx:1992
 AliEMCALRecoUtils.cxx:1993
 AliEMCALRecoUtils.cxx:1994
 AliEMCALRecoUtils.cxx:1995
 AliEMCALRecoUtils.cxx:1996
 AliEMCALRecoUtils.cxx:1997
 AliEMCALRecoUtils.cxx:1998
 AliEMCALRecoUtils.cxx:1999
 AliEMCALRecoUtils.cxx:2000
 AliEMCALRecoUtils.cxx:2001
 AliEMCALRecoUtils.cxx:2002
 AliEMCALRecoUtils.cxx:2003
 AliEMCALRecoUtils.cxx:2004
 AliEMCALRecoUtils.cxx:2005
 AliEMCALRecoUtils.cxx:2006
 AliEMCALRecoUtils.cxx:2007
 AliEMCALRecoUtils.cxx:2008
 AliEMCALRecoUtils.cxx:2009
 AliEMCALRecoUtils.cxx:2010
 AliEMCALRecoUtils.cxx:2011
 AliEMCALRecoUtils.cxx:2012
 AliEMCALRecoUtils.cxx:2013
 AliEMCALRecoUtils.cxx:2014
 AliEMCALRecoUtils.cxx:2015
 AliEMCALRecoUtils.cxx:2016
 AliEMCALRecoUtils.cxx:2017
 AliEMCALRecoUtils.cxx:2018
 AliEMCALRecoUtils.cxx:2019
 AliEMCALRecoUtils.cxx:2020
 AliEMCALRecoUtils.cxx:2021
 AliEMCALRecoUtils.cxx:2022
 AliEMCALRecoUtils.cxx:2023
 AliEMCALRecoUtils.cxx:2024
 AliEMCALRecoUtils.cxx:2025
 AliEMCALRecoUtils.cxx:2026
 AliEMCALRecoUtils.cxx:2027
 AliEMCALRecoUtils.cxx:2028
 AliEMCALRecoUtils.cxx:2029
 AliEMCALRecoUtils.cxx:2030
 AliEMCALRecoUtils.cxx:2031
 AliEMCALRecoUtils.cxx:2032
 AliEMCALRecoUtils.cxx:2033
 AliEMCALRecoUtils.cxx:2034
 AliEMCALRecoUtils.cxx:2035
 AliEMCALRecoUtils.cxx:2036
 AliEMCALRecoUtils.cxx:2037
 AliEMCALRecoUtils.cxx:2038
 AliEMCALRecoUtils.cxx:2039
 AliEMCALRecoUtils.cxx:2040
 AliEMCALRecoUtils.cxx:2041
 AliEMCALRecoUtils.cxx:2042
 AliEMCALRecoUtils.cxx:2043
 AliEMCALRecoUtils.cxx:2044
 AliEMCALRecoUtils.cxx:2045
 AliEMCALRecoUtils.cxx:2046
 AliEMCALRecoUtils.cxx:2047
 AliEMCALRecoUtils.cxx:2048
 AliEMCALRecoUtils.cxx:2049
 AliEMCALRecoUtils.cxx:2050
 AliEMCALRecoUtils.cxx:2051
 AliEMCALRecoUtils.cxx:2052
 AliEMCALRecoUtils.cxx:2053
 AliEMCALRecoUtils.cxx:2054
 AliEMCALRecoUtils.cxx:2055
 AliEMCALRecoUtils.cxx:2056
 AliEMCALRecoUtils.cxx:2057
 AliEMCALRecoUtils.cxx:2058
 AliEMCALRecoUtils.cxx:2059
 AliEMCALRecoUtils.cxx:2060
 AliEMCALRecoUtils.cxx:2061
 AliEMCALRecoUtils.cxx:2062
 AliEMCALRecoUtils.cxx:2063
 AliEMCALRecoUtils.cxx:2064
 AliEMCALRecoUtils.cxx:2065
 AliEMCALRecoUtils.cxx:2066
 AliEMCALRecoUtils.cxx:2067
 AliEMCALRecoUtils.cxx:2068
 AliEMCALRecoUtils.cxx:2069
 AliEMCALRecoUtils.cxx:2070
 AliEMCALRecoUtils.cxx:2071
 AliEMCALRecoUtils.cxx:2072
 AliEMCALRecoUtils.cxx:2073
 AliEMCALRecoUtils.cxx:2074
 AliEMCALRecoUtils.cxx:2075
 AliEMCALRecoUtils.cxx:2076
 AliEMCALRecoUtils.cxx:2077
 AliEMCALRecoUtils.cxx:2078
 AliEMCALRecoUtils.cxx:2079
 AliEMCALRecoUtils.cxx:2080
 AliEMCALRecoUtils.cxx:2081
 AliEMCALRecoUtils.cxx:2082
 AliEMCALRecoUtils.cxx:2083
 AliEMCALRecoUtils.cxx:2084
 AliEMCALRecoUtils.cxx:2085
 AliEMCALRecoUtils.cxx:2086
 AliEMCALRecoUtils.cxx:2087
 AliEMCALRecoUtils.cxx:2088
 AliEMCALRecoUtils.cxx:2089
 AliEMCALRecoUtils.cxx:2090
 AliEMCALRecoUtils.cxx:2091
 AliEMCALRecoUtils.cxx:2092
 AliEMCALRecoUtils.cxx:2093
 AliEMCALRecoUtils.cxx:2094
 AliEMCALRecoUtils.cxx:2095
 AliEMCALRecoUtils.cxx:2096
 AliEMCALRecoUtils.cxx:2097
 AliEMCALRecoUtils.cxx:2098
 AliEMCALRecoUtils.cxx:2099
 AliEMCALRecoUtils.cxx:2100
 AliEMCALRecoUtils.cxx:2101
 AliEMCALRecoUtils.cxx:2102
 AliEMCALRecoUtils.cxx:2103
 AliEMCALRecoUtils.cxx:2104
 AliEMCALRecoUtils.cxx:2105
 AliEMCALRecoUtils.cxx:2106
 AliEMCALRecoUtils.cxx:2107
 AliEMCALRecoUtils.cxx:2108
 AliEMCALRecoUtils.cxx:2109
 AliEMCALRecoUtils.cxx:2110
 AliEMCALRecoUtils.cxx:2111
 AliEMCALRecoUtils.cxx:2112
 AliEMCALRecoUtils.cxx:2113
 AliEMCALRecoUtils.cxx:2114
 AliEMCALRecoUtils.cxx:2115
 AliEMCALRecoUtils.cxx:2116
 AliEMCALRecoUtils.cxx:2117
 AliEMCALRecoUtils.cxx:2118
 AliEMCALRecoUtils.cxx:2119
 AliEMCALRecoUtils.cxx:2120
 AliEMCALRecoUtils.cxx:2121
 AliEMCALRecoUtils.cxx:2122
 AliEMCALRecoUtils.cxx:2123
 AliEMCALRecoUtils.cxx:2124
 AliEMCALRecoUtils.cxx:2125
 AliEMCALRecoUtils.cxx:2126
 AliEMCALRecoUtils.cxx:2127
 AliEMCALRecoUtils.cxx:2128
 AliEMCALRecoUtils.cxx:2129
 AliEMCALRecoUtils.cxx:2130
 AliEMCALRecoUtils.cxx:2131
 AliEMCALRecoUtils.cxx:2132
 AliEMCALRecoUtils.cxx:2133
 AliEMCALRecoUtils.cxx:2134
 AliEMCALRecoUtils.cxx:2135
 AliEMCALRecoUtils.cxx:2136
 AliEMCALRecoUtils.cxx:2137
 AliEMCALRecoUtils.cxx:2138
 AliEMCALRecoUtils.cxx:2139
 AliEMCALRecoUtils.cxx:2140
 AliEMCALRecoUtils.cxx:2141
 AliEMCALRecoUtils.cxx:2142
 AliEMCALRecoUtils.cxx:2143
 AliEMCALRecoUtils.cxx:2144
 AliEMCALRecoUtils.cxx:2145
 AliEMCALRecoUtils.cxx:2146
 AliEMCALRecoUtils.cxx:2147
 AliEMCALRecoUtils.cxx:2148
 AliEMCALRecoUtils.cxx:2149
 AliEMCALRecoUtils.cxx:2150
 AliEMCALRecoUtils.cxx:2151
 AliEMCALRecoUtils.cxx:2152
 AliEMCALRecoUtils.cxx:2153
 AliEMCALRecoUtils.cxx:2154
 AliEMCALRecoUtils.cxx:2155
 AliEMCALRecoUtils.cxx:2156
 AliEMCALRecoUtils.cxx:2157
 AliEMCALRecoUtils.cxx:2158
 AliEMCALRecoUtils.cxx:2159
 AliEMCALRecoUtils.cxx:2160
 AliEMCALRecoUtils.cxx:2161
 AliEMCALRecoUtils.cxx:2162
 AliEMCALRecoUtils.cxx:2163
 AliEMCALRecoUtils.cxx:2164
 AliEMCALRecoUtils.cxx:2165
 AliEMCALRecoUtils.cxx:2166
 AliEMCALRecoUtils.cxx:2167
 AliEMCALRecoUtils.cxx:2168
 AliEMCALRecoUtils.cxx:2169
 AliEMCALRecoUtils.cxx:2170
 AliEMCALRecoUtils.cxx:2171
 AliEMCALRecoUtils.cxx:2172
 AliEMCALRecoUtils.cxx:2173
 AliEMCALRecoUtils.cxx:2174
 AliEMCALRecoUtils.cxx:2175
 AliEMCALRecoUtils.cxx:2176
 AliEMCALRecoUtils.cxx:2177
 AliEMCALRecoUtils.cxx:2178
 AliEMCALRecoUtils.cxx:2179
 AliEMCALRecoUtils.cxx:2180
 AliEMCALRecoUtils.cxx:2181
 AliEMCALRecoUtils.cxx:2182
 AliEMCALRecoUtils.cxx:2183
 AliEMCALRecoUtils.cxx:2184
 AliEMCALRecoUtils.cxx:2185
 AliEMCALRecoUtils.cxx:2186
 AliEMCALRecoUtils.cxx:2187
 AliEMCALRecoUtils.cxx:2188
 AliEMCALRecoUtils.cxx:2189
 AliEMCALRecoUtils.cxx:2190
 AliEMCALRecoUtils.cxx:2191
 AliEMCALRecoUtils.cxx:2192
 AliEMCALRecoUtils.cxx:2193
 AliEMCALRecoUtils.cxx:2194
 AliEMCALRecoUtils.cxx:2195
 AliEMCALRecoUtils.cxx:2196
 AliEMCALRecoUtils.cxx:2197
 AliEMCALRecoUtils.cxx:2198
 AliEMCALRecoUtils.cxx:2199
 AliEMCALRecoUtils.cxx:2200
 AliEMCALRecoUtils.cxx:2201
 AliEMCALRecoUtils.cxx:2202
 AliEMCALRecoUtils.cxx:2203
 AliEMCALRecoUtils.cxx:2204
 AliEMCALRecoUtils.cxx:2205
 AliEMCALRecoUtils.cxx:2206
 AliEMCALRecoUtils.cxx:2207
 AliEMCALRecoUtils.cxx:2208
 AliEMCALRecoUtils.cxx:2209
 AliEMCALRecoUtils.cxx:2210
 AliEMCALRecoUtils.cxx:2211
 AliEMCALRecoUtils.cxx:2212
 AliEMCALRecoUtils.cxx:2213
 AliEMCALRecoUtils.cxx:2214
 AliEMCALRecoUtils.cxx:2215
 AliEMCALRecoUtils.cxx:2216
 AliEMCALRecoUtils.cxx:2217
 AliEMCALRecoUtils.cxx:2218
 AliEMCALRecoUtils.cxx:2219
 AliEMCALRecoUtils.cxx:2220
 AliEMCALRecoUtils.cxx:2221
 AliEMCALRecoUtils.cxx:2222
 AliEMCALRecoUtils.cxx:2223
 AliEMCALRecoUtils.cxx:2224
 AliEMCALRecoUtils.cxx:2225
 AliEMCALRecoUtils.cxx:2226
 AliEMCALRecoUtils.cxx:2227
 AliEMCALRecoUtils.cxx:2228
 AliEMCALRecoUtils.cxx:2229
 AliEMCALRecoUtils.cxx:2230
 AliEMCALRecoUtils.cxx:2231
 AliEMCALRecoUtils.cxx:2232
 AliEMCALRecoUtils.cxx:2233
 AliEMCALRecoUtils.cxx:2234
 AliEMCALRecoUtils.cxx:2235
 AliEMCALRecoUtils.cxx:2236
 AliEMCALRecoUtils.cxx:2237
 AliEMCALRecoUtils.cxx:2238
 AliEMCALRecoUtils.cxx:2239
 AliEMCALRecoUtils.cxx:2240
 AliEMCALRecoUtils.cxx:2241
 AliEMCALRecoUtils.cxx:2242
 AliEMCALRecoUtils.cxx:2243
 AliEMCALRecoUtils.cxx:2244
 AliEMCALRecoUtils.cxx:2245
 AliEMCALRecoUtils.cxx:2246
 AliEMCALRecoUtils.cxx:2247
 AliEMCALRecoUtils.cxx:2248
 AliEMCALRecoUtils.cxx:2249
 AliEMCALRecoUtils.cxx:2250
 AliEMCALRecoUtils.cxx:2251
 AliEMCALRecoUtils.cxx:2252
 AliEMCALRecoUtils.cxx:2253
 AliEMCALRecoUtils.cxx:2254
 AliEMCALRecoUtils.cxx:2255
 AliEMCALRecoUtils.cxx:2256
 AliEMCALRecoUtils.cxx:2257
 AliEMCALRecoUtils.cxx:2258
 AliEMCALRecoUtils.cxx:2259
 AliEMCALRecoUtils.cxx:2260
 AliEMCALRecoUtils.cxx:2261
 AliEMCALRecoUtils.cxx:2262
 AliEMCALRecoUtils.cxx:2263
 AliEMCALRecoUtils.cxx:2264
 AliEMCALRecoUtils.cxx:2265
 AliEMCALRecoUtils.cxx:2266
 AliEMCALRecoUtils.cxx:2267
 AliEMCALRecoUtils.cxx:2268
 AliEMCALRecoUtils.cxx:2269
 AliEMCALRecoUtils.cxx:2270
 AliEMCALRecoUtils.cxx:2271
 AliEMCALRecoUtils.cxx:2272
 AliEMCALRecoUtils.cxx:2273
 AliEMCALRecoUtils.cxx:2274
 AliEMCALRecoUtils.cxx:2275
 AliEMCALRecoUtils.cxx:2276
 AliEMCALRecoUtils.cxx:2277
 AliEMCALRecoUtils.cxx:2278
 AliEMCALRecoUtils.cxx:2279
 AliEMCALRecoUtils.cxx:2280
 AliEMCALRecoUtils.cxx:2281
 AliEMCALRecoUtils.cxx:2282
 AliEMCALRecoUtils.cxx:2283
 AliEMCALRecoUtils.cxx:2284
 AliEMCALRecoUtils.cxx:2285
 AliEMCALRecoUtils.cxx:2286
 AliEMCALRecoUtils.cxx:2287
 AliEMCALRecoUtils.cxx:2288
 AliEMCALRecoUtils.cxx:2289
 AliEMCALRecoUtils.cxx:2290
 AliEMCALRecoUtils.cxx:2291
 AliEMCALRecoUtils.cxx:2292
 AliEMCALRecoUtils.cxx:2293
 AliEMCALRecoUtils.cxx:2294
 AliEMCALRecoUtils.cxx:2295
 AliEMCALRecoUtils.cxx:2296
 AliEMCALRecoUtils.cxx:2297
 AliEMCALRecoUtils.cxx:2298
 AliEMCALRecoUtils.cxx:2299
 AliEMCALRecoUtils.cxx:2300
 AliEMCALRecoUtils.cxx:2301
 AliEMCALRecoUtils.cxx:2302
 AliEMCALRecoUtils.cxx:2303
 AliEMCALRecoUtils.cxx:2304
 AliEMCALRecoUtils.cxx:2305
 AliEMCALRecoUtils.cxx:2306
 AliEMCALRecoUtils.cxx:2307
 AliEMCALRecoUtils.cxx:2308
 AliEMCALRecoUtils.cxx:2309
 AliEMCALRecoUtils.cxx:2310
 AliEMCALRecoUtils.cxx:2311
 AliEMCALRecoUtils.cxx:2312
 AliEMCALRecoUtils.cxx:2313
 AliEMCALRecoUtils.cxx:2314
 AliEMCALRecoUtils.cxx:2315
 AliEMCALRecoUtils.cxx:2316
 AliEMCALRecoUtils.cxx:2317
 AliEMCALRecoUtils.cxx:2318
 AliEMCALRecoUtils.cxx:2319
 AliEMCALRecoUtils.cxx:2320
 AliEMCALRecoUtils.cxx:2321
 AliEMCALRecoUtils.cxx:2322
 AliEMCALRecoUtils.cxx:2323
 AliEMCALRecoUtils.cxx:2324
 AliEMCALRecoUtils.cxx:2325
 AliEMCALRecoUtils.cxx:2326
 AliEMCALRecoUtils.cxx:2327
 AliEMCALRecoUtils.cxx:2328
 AliEMCALRecoUtils.cxx:2329
 AliEMCALRecoUtils.cxx:2330
 AliEMCALRecoUtils.cxx:2331
 AliEMCALRecoUtils.cxx:2332
 AliEMCALRecoUtils.cxx:2333
 AliEMCALRecoUtils.cxx:2334
 AliEMCALRecoUtils.cxx:2335
 AliEMCALRecoUtils.cxx:2336
 AliEMCALRecoUtils.cxx:2337
 AliEMCALRecoUtils.cxx:2338
 AliEMCALRecoUtils.cxx:2339
 AliEMCALRecoUtils.cxx:2340
 AliEMCALRecoUtils.cxx:2341
 AliEMCALRecoUtils.cxx:2342
 AliEMCALRecoUtils.cxx:2343
 AliEMCALRecoUtils.cxx:2344
 AliEMCALRecoUtils.cxx:2345
 AliEMCALRecoUtils.cxx:2346
 AliEMCALRecoUtils.cxx:2347
 AliEMCALRecoUtils.cxx:2348
 AliEMCALRecoUtils.cxx:2349
 AliEMCALRecoUtils.cxx:2350
 AliEMCALRecoUtils.cxx:2351
 AliEMCALRecoUtils.cxx:2352
 AliEMCALRecoUtils.cxx:2353
 AliEMCALRecoUtils.cxx:2354
 AliEMCALRecoUtils.cxx:2355
 AliEMCALRecoUtils.cxx:2356
 AliEMCALRecoUtils.cxx:2357
 AliEMCALRecoUtils.cxx:2358
 AliEMCALRecoUtils.cxx:2359
 AliEMCALRecoUtils.cxx:2360
 AliEMCALRecoUtils.cxx:2361
 AliEMCALRecoUtils.cxx:2362
 AliEMCALRecoUtils.cxx:2363
 AliEMCALRecoUtils.cxx:2364
 AliEMCALRecoUtils.cxx:2365
 AliEMCALRecoUtils.cxx:2366
 AliEMCALRecoUtils.cxx:2367
 AliEMCALRecoUtils.cxx:2368
 AliEMCALRecoUtils.cxx:2369
 AliEMCALRecoUtils.cxx:2370
 AliEMCALRecoUtils.cxx:2371
 AliEMCALRecoUtils.cxx:2372
 AliEMCALRecoUtils.cxx:2373
 AliEMCALRecoUtils.cxx:2374
 AliEMCALRecoUtils.cxx:2375
 AliEMCALRecoUtils.cxx:2376
 AliEMCALRecoUtils.cxx:2377
 AliEMCALRecoUtils.cxx:2378
 AliEMCALRecoUtils.cxx:2379
 AliEMCALRecoUtils.cxx:2380
 AliEMCALRecoUtils.cxx:2381
 AliEMCALRecoUtils.cxx:2382
 AliEMCALRecoUtils.cxx:2383
 AliEMCALRecoUtils.cxx:2384
 AliEMCALRecoUtils.cxx:2385
 AliEMCALRecoUtils.cxx:2386
 AliEMCALRecoUtils.cxx:2387
 AliEMCALRecoUtils.cxx:2388
 AliEMCALRecoUtils.cxx:2389
 AliEMCALRecoUtils.cxx:2390
 AliEMCALRecoUtils.cxx:2391
 AliEMCALRecoUtils.cxx:2392
 AliEMCALRecoUtils.cxx:2393
 AliEMCALRecoUtils.cxx:2394
 AliEMCALRecoUtils.cxx:2395
 AliEMCALRecoUtils.cxx:2396
 AliEMCALRecoUtils.cxx:2397
 AliEMCALRecoUtils.cxx:2398
 AliEMCALRecoUtils.cxx:2399
 AliEMCALRecoUtils.cxx:2400
 AliEMCALRecoUtils.cxx:2401
 AliEMCALRecoUtils.cxx:2402
 AliEMCALRecoUtils.cxx:2403
 AliEMCALRecoUtils.cxx:2404
 AliEMCALRecoUtils.cxx:2405
 AliEMCALRecoUtils.cxx:2406
 AliEMCALRecoUtils.cxx:2407
 AliEMCALRecoUtils.cxx:2408
 AliEMCALRecoUtils.cxx:2409
 AliEMCALRecoUtils.cxx:2410
 AliEMCALRecoUtils.cxx:2411
 AliEMCALRecoUtils.cxx:2412
 AliEMCALRecoUtils.cxx:2413
 AliEMCALRecoUtils.cxx:2414
 AliEMCALRecoUtils.cxx:2415
 AliEMCALRecoUtils.cxx:2416
 AliEMCALRecoUtils.cxx:2417
 AliEMCALRecoUtils.cxx:2418
 AliEMCALRecoUtils.cxx:2419
 AliEMCALRecoUtils.cxx:2420
 AliEMCALRecoUtils.cxx:2421
 AliEMCALRecoUtils.cxx:2422
 AliEMCALRecoUtils.cxx:2423
 AliEMCALRecoUtils.cxx:2424
 AliEMCALRecoUtils.cxx:2425
 AliEMCALRecoUtils.cxx:2426
 AliEMCALRecoUtils.cxx:2427
 AliEMCALRecoUtils.cxx:2428
 AliEMCALRecoUtils.cxx:2429
 AliEMCALRecoUtils.cxx:2430
 AliEMCALRecoUtils.cxx:2431
 AliEMCALRecoUtils.cxx:2432
 AliEMCALRecoUtils.cxx:2433
 AliEMCALRecoUtils.cxx:2434
 AliEMCALRecoUtils.cxx:2435
 AliEMCALRecoUtils.cxx:2436
 AliEMCALRecoUtils.cxx:2437
 AliEMCALRecoUtils.cxx:2438
 AliEMCALRecoUtils.cxx:2439
 AliEMCALRecoUtils.cxx:2440
 AliEMCALRecoUtils.cxx:2441
 AliEMCALRecoUtils.cxx:2442
 AliEMCALRecoUtils.cxx:2443
 AliEMCALRecoUtils.cxx:2444
 AliEMCALRecoUtils.cxx:2445
 AliEMCALRecoUtils.cxx:2446
 AliEMCALRecoUtils.cxx:2447
 AliEMCALRecoUtils.cxx:2448
 AliEMCALRecoUtils.cxx:2449
 AliEMCALRecoUtils.cxx:2450
 AliEMCALRecoUtils.cxx:2451
 AliEMCALRecoUtils.cxx:2452
 AliEMCALRecoUtils.cxx:2453
 AliEMCALRecoUtils.cxx:2454
 AliEMCALRecoUtils.cxx:2455
 AliEMCALRecoUtils.cxx:2456
 AliEMCALRecoUtils.cxx:2457
 AliEMCALRecoUtils.cxx:2458
 AliEMCALRecoUtils.cxx:2459
 AliEMCALRecoUtils.cxx:2460
 AliEMCALRecoUtils.cxx:2461
 AliEMCALRecoUtils.cxx:2462
 AliEMCALRecoUtils.cxx:2463
 AliEMCALRecoUtils.cxx:2464
 AliEMCALRecoUtils.cxx:2465
 AliEMCALRecoUtils.cxx:2466
 AliEMCALRecoUtils.cxx:2467
 AliEMCALRecoUtils.cxx:2468
 AliEMCALRecoUtils.cxx:2469
 AliEMCALRecoUtils.cxx:2470
 AliEMCALRecoUtils.cxx:2471
 AliEMCALRecoUtils.cxx:2472
 AliEMCALRecoUtils.cxx:2473
 AliEMCALRecoUtils.cxx:2474
 AliEMCALRecoUtils.cxx:2475
 AliEMCALRecoUtils.cxx:2476
 AliEMCALRecoUtils.cxx:2477
 AliEMCALRecoUtils.cxx:2478
 AliEMCALRecoUtils.cxx:2479
 AliEMCALRecoUtils.cxx:2480
 AliEMCALRecoUtils.cxx:2481
 AliEMCALRecoUtils.cxx:2482
 AliEMCALRecoUtils.cxx:2483
 AliEMCALRecoUtils.cxx:2484
 AliEMCALRecoUtils.cxx:2485
 AliEMCALRecoUtils.cxx:2486
 AliEMCALRecoUtils.cxx:2487
 AliEMCALRecoUtils.cxx:2488
 AliEMCALRecoUtils.cxx:2489
 AliEMCALRecoUtils.cxx:2490
 AliEMCALRecoUtils.cxx:2491
 AliEMCALRecoUtils.cxx:2492
 AliEMCALRecoUtils.cxx:2493
 AliEMCALRecoUtils.cxx:2494
 AliEMCALRecoUtils.cxx:2495
 AliEMCALRecoUtils.cxx:2496
 AliEMCALRecoUtils.cxx:2497
 AliEMCALRecoUtils.cxx:2498
 AliEMCALRecoUtils.cxx:2499
 AliEMCALRecoUtils.cxx:2500
 AliEMCALRecoUtils.cxx:2501
 AliEMCALRecoUtils.cxx:2502
 AliEMCALRecoUtils.cxx:2503
 AliEMCALRecoUtils.cxx:2504
 AliEMCALRecoUtils.cxx:2505
 AliEMCALRecoUtils.cxx:2506
 AliEMCALRecoUtils.cxx:2507
 AliEMCALRecoUtils.cxx:2508
 AliEMCALRecoUtils.cxx:2509
 AliEMCALRecoUtils.cxx:2510
 AliEMCALRecoUtils.cxx:2511
 AliEMCALRecoUtils.cxx:2512
 AliEMCALRecoUtils.cxx:2513
 AliEMCALRecoUtils.cxx:2514
 AliEMCALRecoUtils.cxx:2515
 AliEMCALRecoUtils.cxx:2516
 AliEMCALRecoUtils.cxx:2517
 AliEMCALRecoUtils.cxx:2518
 AliEMCALRecoUtils.cxx:2519
 AliEMCALRecoUtils.cxx:2520
 AliEMCALRecoUtils.cxx:2521
 AliEMCALRecoUtils.cxx:2522
 AliEMCALRecoUtils.cxx:2523
 AliEMCALRecoUtils.cxx:2524
 AliEMCALRecoUtils.cxx:2525
 AliEMCALRecoUtils.cxx:2526
 AliEMCALRecoUtils.cxx:2527
 AliEMCALRecoUtils.cxx:2528
 AliEMCALRecoUtils.cxx:2529
 AliEMCALRecoUtils.cxx:2530
 AliEMCALRecoUtils.cxx:2531
 AliEMCALRecoUtils.cxx:2532
 AliEMCALRecoUtils.cxx:2533
 AliEMCALRecoUtils.cxx:2534
 AliEMCALRecoUtils.cxx:2535
 AliEMCALRecoUtils.cxx:2536
 AliEMCALRecoUtils.cxx:2537
 AliEMCALRecoUtils.cxx:2538
 AliEMCALRecoUtils.cxx:2539
 AliEMCALRecoUtils.cxx:2540
 AliEMCALRecoUtils.cxx:2541
 AliEMCALRecoUtils.cxx:2542
 AliEMCALRecoUtils.cxx:2543
 AliEMCALRecoUtils.cxx:2544
 AliEMCALRecoUtils.cxx:2545
 AliEMCALRecoUtils.cxx:2546
 AliEMCALRecoUtils.cxx:2547
 AliEMCALRecoUtils.cxx:2548
 AliEMCALRecoUtils.cxx:2549
 AliEMCALRecoUtils.cxx:2550
 AliEMCALRecoUtils.cxx:2551
 AliEMCALRecoUtils.cxx:2552
 AliEMCALRecoUtils.cxx:2553
 AliEMCALRecoUtils.cxx:2554
 AliEMCALRecoUtils.cxx:2555
 AliEMCALRecoUtils.cxx:2556
 AliEMCALRecoUtils.cxx:2557
 AliEMCALRecoUtils.cxx:2558
 AliEMCALRecoUtils.cxx:2559
 AliEMCALRecoUtils.cxx:2560
 AliEMCALRecoUtils.cxx:2561
 AliEMCALRecoUtils.cxx:2562
 AliEMCALRecoUtils.cxx:2563
 AliEMCALRecoUtils.cxx:2564
 AliEMCALRecoUtils.cxx:2565
 AliEMCALRecoUtils.cxx:2566
 AliEMCALRecoUtils.cxx:2567
 AliEMCALRecoUtils.cxx:2568
 AliEMCALRecoUtils.cxx:2569
 AliEMCALRecoUtils.cxx:2570
 AliEMCALRecoUtils.cxx:2571
 AliEMCALRecoUtils.cxx:2572
 AliEMCALRecoUtils.cxx:2573
 AliEMCALRecoUtils.cxx:2574
 AliEMCALRecoUtils.cxx:2575
 AliEMCALRecoUtils.cxx:2576
 AliEMCALRecoUtils.cxx:2577
 AliEMCALRecoUtils.cxx:2578
 AliEMCALRecoUtils.cxx:2579
 AliEMCALRecoUtils.cxx:2580
 AliEMCALRecoUtils.cxx:2581
 AliEMCALRecoUtils.cxx:2582
 AliEMCALRecoUtils.cxx:2583
 AliEMCALRecoUtils.cxx:2584
 AliEMCALRecoUtils.cxx:2585
 AliEMCALRecoUtils.cxx:2586
 AliEMCALRecoUtils.cxx:2587
 AliEMCALRecoUtils.cxx:2588
 AliEMCALRecoUtils.cxx:2589
 AliEMCALRecoUtils.cxx:2590
 AliEMCALRecoUtils.cxx:2591
 AliEMCALRecoUtils.cxx:2592
 AliEMCALRecoUtils.cxx:2593
 AliEMCALRecoUtils.cxx:2594
 AliEMCALRecoUtils.cxx:2595
 AliEMCALRecoUtils.cxx:2596
 AliEMCALRecoUtils.cxx:2597
 AliEMCALRecoUtils.cxx:2598
 AliEMCALRecoUtils.cxx:2599
 AliEMCALRecoUtils.cxx:2600
 AliEMCALRecoUtils.cxx:2601
 AliEMCALRecoUtils.cxx:2602
 AliEMCALRecoUtils.cxx:2603
 AliEMCALRecoUtils.cxx:2604
 AliEMCALRecoUtils.cxx:2605
 AliEMCALRecoUtils.cxx:2606
 AliEMCALRecoUtils.cxx:2607
 AliEMCALRecoUtils.cxx:2608
 AliEMCALRecoUtils.cxx:2609
 AliEMCALRecoUtils.cxx:2610
 AliEMCALRecoUtils.cxx:2611
 AliEMCALRecoUtils.cxx:2612
 AliEMCALRecoUtils.cxx:2613
 AliEMCALRecoUtils.cxx:2614
 AliEMCALRecoUtils.cxx:2615
 AliEMCALRecoUtils.cxx:2616
 AliEMCALRecoUtils.cxx:2617
 AliEMCALRecoUtils.cxx:2618
 AliEMCALRecoUtils.cxx:2619
 AliEMCALRecoUtils.cxx:2620
 AliEMCALRecoUtils.cxx:2621
 AliEMCALRecoUtils.cxx:2622
 AliEMCALRecoUtils.cxx:2623
 AliEMCALRecoUtils.cxx:2624
 AliEMCALRecoUtils.cxx:2625
 AliEMCALRecoUtils.cxx:2626
 AliEMCALRecoUtils.cxx:2627
 AliEMCALRecoUtils.cxx:2628
 AliEMCALRecoUtils.cxx:2629
 AliEMCALRecoUtils.cxx:2630
 AliEMCALRecoUtils.cxx:2631
 AliEMCALRecoUtils.cxx:2632
 AliEMCALRecoUtils.cxx:2633
 AliEMCALRecoUtils.cxx:2634
 AliEMCALRecoUtils.cxx:2635
 AliEMCALRecoUtils.cxx:2636
 AliEMCALRecoUtils.cxx:2637
 AliEMCALRecoUtils.cxx:2638
 AliEMCALRecoUtils.cxx:2639
 AliEMCALRecoUtils.cxx:2640
 AliEMCALRecoUtils.cxx:2641
 AliEMCALRecoUtils.cxx:2642
 AliEMCALRecoUtils.cxx:2643
 AliEMCALRecoUtils.cxx:2644
 AliEMCALRecoUtils.cxx:2645
 AliEMCALRecoUtils.cxx:2646
 AliEMCALRecoUtils.cxx:2647
 AliEMCALRecoUtils.cxx:2648
 AliEMCALRecoUtils.cxx:2649
 AliEMCALRecoUtils.cxx:2650
 AliEMCALRecoUtils.cxx:2651
 AliEMCALRecoUtils.cxx:2652
 AliEMCALRecoUtils.cxx:2653
 AliEMCALRecoUtils.cxx:2654
 AliEMCALRecoUtils.cxx:2655
 AliEMCALRecoUtils.cxx:2656
 AliEMCALRecoUtils.cxx:2657
 AliEMCALRecoUtils.cxx:2658
 AliEMCALRecoUtils.cxx:2659
 AliEMCALRecoUtils.cxx:2660
 AliEMCALRecoUtils.cxx:2661
 AliEMCALRecoUtils.cxx:2662
 AliEMCALRecoUtils.cxx:2663
 AliEMCALRecoUtils.cxx:2664
 AliEMCALRecoUtils.cxx:2665
 AliEMCALRecoUtils.cxx:2666
 AliEMCALRecoUtils.cxx:2667
 AliEMCALRecoUtils.cxx:2668
 AliEMCALRecoUtils.cxx:2669
 AliEMCALRecoUtils.cxx:2670
 AliEMCALRecoUtils.cxx:2671
 AliEMCALRecoUtils.cxx:2672
 AliEMCALRecoUtils.cxx:2673
 AliEMCALRecoUtils.cxx:2674
 AliEMCALRecoUtils.cxx:2675
 AliEMCALRecoUtils.cxx:2676
 AliEMCALRecoUtils.cxx:2677
 AliEMCALRecoUtils.cxx:2678
 AliEMCALRecoUtils.cxx:2679