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.                  *
 **************************************************************************/

//_________________________________________________________________________
// Class for PID selection with calorimeters
// The Output of the main method GetIdentifiedParticleType is a PDG number identifying the cluster, 
// being kPhoton, kElectron, kPi0 ... as defined in the header file
//   - GetIdentifiedParticleType(const AliVCluster * cluster) 
//      Assignes a PID tag to the cluster, right now there is the possibility to : use bayesian weights from reco, 
//      recalculate them (EMCAL) or use other procedures not used in reco.
//      In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
//      and do SwitchOnBayesianRecalculation().
//      To change the PID parameters from Low to High like the ones by default, use the constructor 
//      AliCaloPID(flux)
//      where flux is AliCaloPID::kLow or AliCaloPID::kHigh
//      If it is necessary to change the parameters use the constructor 
//      AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before.

//   - GetGetIdentifiedParticleTypeFromBayesian(const Double_t * pid, const Float_t energy)
//      Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle, 
//      executed when bayesian is ON by GetIdentifiedParticleType(const AliVCluster * cluster) 
//   - SetPIDBits: Simple PID, depending on the thresholds fLOCut fTOFCut and even the
//     result of the PID bayesian a different PID bit is set. 
//
//   - IsTrackMatched(): Independent method that needs to be combined with GetIdentifiedParticleType to know if the cluster was matched
//
//*-- Author: Gustavo Conesa (INFN-LNF)
//////////////////////////////////////////////////////////////////////////////


// --- ROOT system ---
#include <TMath.h>
#include <TString.h>
#include <TList.h>

// ---- ANALYSIS system ----
#include "AliCaloPID.h"
#include "AliAODCaloCluster.h"
#include "AliVCaloCells.h"
#include "AliVTrack.h"
#include "AliAODPWG4Particle.h"
#include "AliCalorimeterUtils.h"
#include "AliVEvent.h"
#include "AliLog.h"

// ---- Detector ----
#include "AliEMCALPIDUtils.h"

ClassImp(AliCaloPID)


//________________________
AliCaloPID::AliCaloPID() : 
TObject(),                fDebug(-1),                  fParticleFlux(kLow),
//Bayesian
fEMCALPIDUtils(),         fUseBayesianWeights(kFALSE), fRecalculateBayesian(kFALSE),
fEMCALPhotonWeight(0.),   fEMCALPi0Weight(0.),  
fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),      fEMCALNeutralWeight(0.),
fPHOSPhotonWeight(0.),    fPHOSPi0Weight(0.),  
fPHOSElectronWeight(0.),  fPHOSChargeWeight(0.) ,      fPHOSNeutralWeight(0.), 
fPHOSWeightFormula(0),    fPHOSPhotonWeightFormula(0), fPHOSPi0WeightFormula(0),
fPHOSPhotonWeightFormulaExpression(""), 
fPHOSPi0WeightFormulaExpression(""),
//PID calculation
fEMCALL0CutMax(100.),     fEMCALL0CutMin(0),           
fEMCALDEtaCut(2000.),     fEMCALDPhiCut(2000.),
fTOFCut(0.), 
fPHOSDispersionCut(1000), fPHOSRCut(1000),
//Split
fUseSimpleMassCut(kFALSE),
fUseSimpleM02Cut(kFALSE),
fUseSplitAsyCut(kFALSE),
fUseSplitSSCut(kTRUE),
fSplitM02MaxCut(0),       fSplitM02MinCut(0),          fSplitMinNCells(0),
fMassEtaMin(0),           fMassEtaMax(0),
fMassPi0Min(0),           fMassPi0Max(0),
fMassPhoMin(0),           fMassPhoMax(0),
fM02MaxParamShiftNLMN(0),
fSplitWidthSigma(0),      fMassShiftHighECell(0)
{
  //Ctor
  
  //Initialize parameters
  InitParameters();
}

//________________________________________
AliCaloPID::AliCaloPID(Int_t flux) :
TObject(),                fDebug(-1),                  fParticleFlux(flux),
//Bayesian
fEMCALPIDUtils(),         fUseBayesianWeights(kFALSE), fRecalculateBayesian(kFALSE),
fEMCALPhotonWeight(0.),   fEMCALPi0Weight(0.),  
fEMCALElectronWeight(0.), fEMCALChargeWeight(0.),      fEMCALNeutralWeight(0.),
fPHOSPhotonWeight(0.),    fPHOSPi0Weight(0.),  
fPHOSElectronWeight(0.),  fPHOSChargeWeight(0.) ,      fPHOSNeutralWeight(0.), 
fPHOSWeightFormula(0),    fPHOSPhotonWeightFormula(0), fPHOSPi0WeightFormula(0),
fPHOSPhotonWeightFormulaExpression(""), 
fPHOSPi0WeightFormulaExpression(""),
//PID calculation
fEMCALL0CutMax(100.),     fEMCALL0CutMin(0),           
fEMCALDEtaCut(2000.),     fEMCALDPhiCut(2000.),
fTOFCut(0.), 
fPHOSDispersionCut(1000), fPHOSRCut(1000),
//Split
fUseSimpleMassCut(kFALSE),
fUseSimpleM02Cut(kFALSE),
fUseSplitAsyCut(kFALSE),
fUseSplitSSCut(kTRUE),
fSplitM02MaxCut(0),       fSplitM02MinCut(0),          fSplitMinNCells(0),
fMassEtaMin(0),           fMassEtaMax(0),
fMassPi0Min(0),           fMassPi0Max(0),
fMassPhoMin(0),           fMassPhoMax(0),
fM02MaxParamShiftNLMN(0),
fSplitWidthSigma(0),      fMassShiftHighECell(0)
{
  //Ctor
	
  //Initialize parameters
  InitParameters();
  
}

//_______________________________________________
AliCaloPID::AliCaloPID(const TNamed * emcalpid) : 
TObject(),                   fDebug(-1),                  fParticleFlux(kLow),
//Bayesian
fEMCALPIDUtils((AliEMCALPIDUtils*)emcalpid),         
fUseBayesianWeights(kFALSE), fRecalculateBayesian(kFALSE),
fEMCALPhotonWeight(0.),      fEMCALPi0Weight(0.),  
fEMCALElectronWeight(0.),    fEMCALChargeWeight(0.),      fEMCALNeutralWeight(0.),
fPHOSPhotonWeight(0.),       fPHOSPi0Weight(0.),  
fPHOSElectronWeight(0.),     fPHOSChargeWeight(0.) ,      fPHOSNeutralWeight(0.), 
fPHOSWeightFormula(0),       fPHOSPhotonWeightFormula(0), fPHOSPi0WeightFormula(0),
fPHOSPhotonWeightFormulaExpression(""), 
fPHOSPi0WeightFormulaExpression(""),
//PID calculation
fEMCALL0CutMax(100.),        fEMCALL0CutMin(0),   
fEMCALDEtaCut(2000.),        fEMCALDPhiCut(2000.),
fTOFCut(0.), 
fPHOSDispersionCut(1000),    fPHOSRCut(1000),
//Split
fUseSimpleMassCut(kFALSE),
fUseSimpleM02Cut(kFALSE),
fUseSplitAsyCut(kFALSE),
fUseSplitSSCut(kTRUE),
fSplitM02MaxCut(0),       fSplitM02MinCut(0),          fSplitMinNCells(0),
fMassEtaMin(0),           fMassEtaMax(0),
fMassPi0Min(0),           fMassPi0Max(0),
fMassPhoMin(0),           fMassPhoMax(0),
fM02MaxParamShiftNLMN(0),
fSplitWidthSigma(0),      fMassShiftHighECell(0)

{
  //Ctor
  
  //Initialize parameters
  InitParameters();
}

//_______________________
AliCaloPID::~AliCaloPID() 
{
  //Dtor
  
  delete fPHOSPhotonWeightFormula ;
  delete fPHOSPi0WeightFormula ;
  delete fEMCALPIDUtils ;
  
}

//_______________________________
void AliCaloPID::InitParameters()
{
  //Initialize the parameters of the PID.
  
  // Bayesian
  fEMCALPhotonWeight   = 0.6 ;
  fEMCALPi0Weight      = 0.6 ;
  fEMCALElectronWeight = 0.6 ;
  fEMCALChargeWeight   = 0.6 ;
  fEMCALNeutralWeight  = 0.6 ;
  
  fPHOSPhotonWeight    = 0.6 ;
  fPHOSPi0Weight       = 0.6 ;
  fPHOSElectronWeight  = 0.6 ;
  fPHOSChargeWeight    = 0.6 ;
  fPHOSNeutralWeight   = 0.6 ;
  
  //Formula to set the PID weight threshold for photon or pi0
  fPHOSWeightFormula       = kFALSE;
  fPHOSPhotonWeightFormulaExpression = "0.98*(x<40)+ 0.68*(x>=100)+(x>=40 && x<100)*(0.98+x*(6e-3)-x*x*(2e-04)+x*x*x*(1.1e-06))";
  fPHOSPi0WeightFormulaExpression    = "0.98*(x<65)+ 0.915*(x>=100)+(x>=65 && x-x*(1.95e-3)-x*x*(4.31e-05)+x*x*x*(3.61e-07))"   ;
  
  if(fRecalculateBayesian)
  {
    if(fParticleFlux == kLow)
    {
      AliInfo("SetLOWFluxParam");
      fEMCALPIDUtils->SetLowFluxParam() ;
    }
    else if (fParticleFlux == kHigh)
    {
      AliInfo("SetHighFluxParam");
      fEMCALPIDUtils->SetHighFluxParam() ;
    }
  }
  
  //PID recalculation, not bayesian
  
  //EMCAL
  fEMCALL0CutMax = 0.3 ;
  fEMCALL0CutMin = 0.01;
  
  fEMCALDPhiCut  = 0.05; // Same cut as in AliEMCALRecoUtils
  fEMCALDEtaCut  = 0.025;// Same cut as in AliEMCALRecoUtils

  // PHOS / EMCAL, not used
  fTOFCut        = 1.e-6;
  
  //PHOS
  fPHOSRCut          = 2. ; 
  fPHOSDispersionCut = 2.5;
  
  // Cluster splitting
  
  fSplitM02MinCut = 0.3 ;
  fSplitM02MaxCut = 5   ;
  fSplitMinNCells = 4   ;

  fMassEtaMin  = 0.4;
  fMassEtaMax  = 0.6;
  
  fMassPi0Min  = 0.11;
  fMassPi0Max  = 0.18;
  
  fMassPhoMin  = 0.0;
  fMassPhoMax  = 0.08;
  
  fMassPi0Param[0][0] = 0     ; // Constant term on mass dependence
  fMassPi0Param[0][1] = 0     ; // slope term on mass dependence
  fMassPi0Param[0][2] = 0     ; // E function change
  fMassPi0Param[0][3] = 0.044 ; // constant term on mass dependence
  fMassPi0Param[0][4] = 0.0049; // slope term on mass dependence
  fMassPi0Param[0][5] = 0.070 ; // Absolute low mass cut
  
  fMassPi0Param[1][0] = 0.115 ; // Constant term below 21 GeV
  fMassPi0Param[1][1] = 0.00096; // slope term below 21 GeV
  fMassPi0Param[1][2] = 21    ; // E function change
  fMassPi0Param[1][3] = 0.10  ; // constant term on mass dependence
  fMassPi0Param[1][4] = 0.0017; // slope term on mass dependence
  fMassPi0Param[1][5] = 0.070 ; // Absolute low mass cut
  
  fWidthPi0Param[0][0] = 0.012 ; // Constant term on width dependence
  fWidthPi0Param[0][1] = 0.0   ; // Slope term on width dependence
  fWidthPi0Param[0][2] = 19    ; // E function change
  fWidthPi0Param[0][3] = 0.0012; // Constant term on width dependence
  fWidthPi0Param[0][4] = 0.0006; // Slope term on width dependence
  fWidthPi0Param[0][5] = 0.0   ; // xx term

  fWidthPi0Param[1][0] = 0.009 ; // Constant term on width dependence
  fWidthPi0Param[1][1] = 0.000 ; // Slope term on width dependence
  fWidthPi0Param[1][2] = 10    ; // E function change
  fWidthPi0Param[1][3] = 0.0023 ; // Constant term on width dependence
  fWidthPi0Param[1][4] = 0.00067; // Slope term on width dependence
  fWidthPi0Param[1][5] = 0.000 ;// xx term

  fMassShiftHighECell = 0; // Shift of cuts in case of higher energy threshold in cells, 5 MeV when Ecell>150 MeV
  
  //TF1 *lM02MinNLM1 = new TF1("M02MinNLM1","exp(2.135-0.245*x)",6,13.6);
  fM02MinParam[0][0] = 2.135  ; 
  fM02MinParam[0][1] =-0.245  ;
  fM02MinParam[0][2] = 0.0    ; 
  fM02MinParam[0][3] = 0.0    ;
  fM02MinParam[0][4] = 0.0    ;

  // Same as NLM=1 for NLM=2
  fM02MinParam[1][0] = 2.135  ;
  fM02MinParam[1][1] =-0.245  ;
  fM02MinParam[1][2] = 0.0    ;
  fM02MinParam[1][3] = 0.0    ;
  fM02MinParam[1][4] = 0.0    ;

  //TF1 *lM02MaxNLM1 = new TF1("M02MaxNLM1","exp(0.0662-0.0201*x)-0.0955+0.00186*x[0]+9.91/x[0]",6,100);
  fM02MaxParam[0][0] = 0.0662 ;
  fM02MaxParam[0][1] =-0.0201 ;
  fM02MaxParam[0][2] =-0.0955 ;
  fM02MaxParam[0][3] = 0.00186;
  fM02MaxParam[0][4] = 9.91   ;
  
  //TF1 *lM02MaxNLM2 = new TF1("M02MaxNLM2","exp(0.353-0.0264*x)-0.524+0.00559*x[0]+21.9/x[0]",6,100);
  fM02MaxParam[1][0] = 0.353  ;  
  fM02MaxParam[1][1] =-0.0264 ;  
  fM02MaxParam[1][2] =-0.524  ; 
  fM02MaxParam[1][3] = 0.00559;
  fM02MaxParam[1][4] = 21.9   ;
  
  fM02MaxParamShiftNLMN = 0.75;
  
  //TF1 *lAsyNLM1 = new TF1("lAsyNLM1","0.96-879/(x*x*x)",5,100);
  fAsyMinParam[0][0] = 0.96 ;
  fAsyMinParam[0][1] = 0    ;
  fAsyMinParam[0][2] =-879  ;
  fAsyMinParam[0][3] = 0.96 ; // Absolute max

  //TF1 *lAsyNLM2 = new TF1("lAsyNLM2","0.95+0.0015*x-233/(x*x*x)",5,100);
  fAsyMinParam[1][0] = 0.95  ;
  fAsyMinParam[1][1] = 0.0015;
  fAsyMinParam[1][2] =-233   ;
  fAsyMinParam[1][3] = 1.0   ; // Absolute max

  fSplitEFracMin[0]   = 0.0 ; // 0.96
  fSplitEFracMin[1]   = 0.0 ; // 0.96
  fSplitEFracMin[2]   = 0.0 ; // 0.7

  fSubClusterEMin[0]  = 0.0; // 3 GeV
  fSubClusterEMin[1]  = 0.0; // 1 GeV
  fSubClusterEMin[2]  = 0.0; // 1 GeV
  
  
  fSplitWidthSigma = 3. ;
  
}


//_________________________________________________________________________________________
Bool_t AliCaloPID::IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy, Int_t nlm) const
{
  // Select the appropriate mass range for pi0 selection in splitting method
  // No used yet in splitting ID decision
  
  if(!fUseSplitAsyCut) return kTRUE ;
  
  Float_t abasy = TMath::Abs(asy);

  Int_t inlm = nlm-1;
  if(nlm > 2) inlm=1; // only 2 cases defined nlm=1 and nlm>=2
  
  // Get the parametrized min cut of asymmetry for NLM=2 up to 11 GeV

  Float_t cut = fAsyMinParam[inlm][0] + fAsyMinParam[inlm][1]*energy + fAsyMinParam[inlm][2]/energy/energy/energy ;
  
  // In any case and beyond validity energy range of the function,
  // the parameter cannot be smaller than 1
  if( cut > fAsyMinParam[inlm][3] ) cut = fAsyMinParam[inlm][3];
  
  //printf("energy %2.2f - nlm: %d (%d)- p0 %f, p1 %f, p2 %f, p3 %f ; cut: %2.2f\n",energy,nlm,inlm,
  //       fAsyMinParam[inlm][0],fAsyMinParam[inlm][1],fAsyMinParam[inlm][2],fAsyMinParam[inlm][3],cut);
  
  if(abasy < cut) return kTRUE;
  else            return kFALSE;
  
}

//______________________________________________________________________________________
Bool_t AliCaloPID::IsInPi0SplitMassRange(Float_t energy, Float_t mass, Int_t nlm) const
{
  // Select the appropriate mass range for pi0 selection in splitting method
  
  if(fUseSimpleMassCut)
  {
    if(mass < fMassPi0Max && mass > fMassPi0Min) return kTRUE;
    else                                         return kFALSE;
  }
  
  // Get the selected mean value as reference for the mass
  Int_t inlm = nlm-1;
  if(nlm > 2) inlm=1; // only 2 cases defined nlm=1 and nlm>=2
    
  Float_t meanMass = energy * fMassPi0Param[inlm][1] + fMassPi0Param[inlm][0];
  if(energy > fMassPi0Param[inlm][2]) meanMass = energy * fMassPi0Param[inlm][4] + fMassPi0Param[inlm][3];
  
  // In case of higher energy cell cut than 50 MeV, smaller mean mass 0-5 MeV, not really necessary
  meanMass -= fMassShiftHighECell;
  
  // Get the parametrized width of the mass
  Float_t width   = 0.009;
  if     (energy > 8 && energy < fWidthPi0Param[inlm][2])
    width = energy * fWidthPi0Param[inlm][1] + fWidthPi0Param[inlm][0];
  else if(              energy > fWidthPi0Param[inlm][2])
    width = energy * energy * fWidthPi0Param[inlm][5] + energy * fWidthPi0Param[inlm][4] + fWidthPi0Param[inlm][3];

  // Calculate the 2 sigma cut
  Float_t minMass = meanMass-fSplitWidthSigma*width;
  Float_t maxMass = meanMass+fSplitWidthSigma*width;

  // In case of low energy, hard cut to avoid conversions
  if(energy < 10  && minMass < fMassPi0Param[inlm][5] ) minMass = fMassPi0Param[inlm][5];
  
  //printf("E %2.2f, mass %1.1f, nlm %d: sigma %1.1f width %3.1f, mean Mass %3.0f, minMass %3.0f, maxMass %3.0f\n ",
  //       energy,mass *1000, inlm, fSplitWidthSigma, width*1000, meanMass*1000,minMass*1000,maxMass*1000);
  
  if(mass < maxMass && mass > minMass) return kTRUE;
  else                                 return kFALSE;
  
}

//________________________________________________
Bool_t AliCaloPID::IsInM02Range(Float_t m02) const
{
  // Select the appropriate m02 range, fix cut, not E dependent 
    
  Float_t minCut = fSplitM02MinCut;
  Float_t maxCut = fSplitM02MaxCut;

  if(m02 < maxCut && m02 > minCut) return kTRUE;
  else                             return kFALSE;
  
}

//_______________________________________________________________________________
Bool_t AliCaloPID::IsInPi0M02Range(Float_t energy, Float_t m02,  Int_t nlm) const
{
  // Select the appropriate m02 range in splitting method for pi0
  
  if(!fUseSplitSSCut) return kTRUE ;

  //First check the absolute minimum and maximum
  if(!IsInM02Range(m02)) return kFALSE ;
  
  //If requested, check the E dependent cuts
  else if(!fUseSimpleM02Cut)
  {
    Int_t inlm = nlm-1;
    if(nlm > 2) inlm=1; // only 2 cases defined nlm=1 and nlm>=2

    Float_t minCut = fSplitM02MinCut;
    Float_t maxCut = fSplitM02MaxCut;
    
    //e^{a+bx} + c + dx + e/x
    if(energy > 1) minCut = TMath::Exp( fM02MinParam[inlm][0] + fM02MinParam[inlm][1]*energy ) +
                            fM02MinParam[inlm][2] + fM02MinParam[inlm][3]*energy + fM02MinParam[inlm][4]/energy;
    
    if(energy > 1) maxCut = TMath::Exp( fM02MaxParam[inlm][0] + fM02MaxParam[inlm][1]*energy ) +
                            fM02MaxParam[inlm][2] + fM02MaxParam[inlm][3]*energy + fM02MaxParam[inlm][4]/energy;
    
    // In any case and beyond validity energy range of the function,
    // the parameter cannot be smaller than 0.3 or larger than 4-5
    if( minCut < fSplitM02MinCut) minCut = fSplitM02MinCut;
    if( maxCut > fSplitM02MaxCut) maxCut = fSplitM02MaxCut;
    if( nlm > 2 ) maxCut+=fM02MaxParamShiftNLMN;
    
    //if(energy > 7) printf("\t \t E %2.2f, nlm %d, m02 %2.2f, minM02 %2.2f, maxM02 %2.2f\n",energy, nlm, m02,minCut,maxCut);
    
    if(m02 < maxCut && m02 > minCut) return kTRUE;
    else                             return kFALSE;
    
  }
  
  else return kTRUE;
  
}


//______________________________________________________________________________
Bool_t AliCaloPID::IsInEtaM02Range(Float_t energy, Float_t m02, Int_t nlm) const
{
  // Select the appropriate m02 range in splitting method to select eta's
  // Use same parametrization as pi0, just shift the distributions (to be tuned)
  
  if(!fUseSplitSSCut) return kTRUE ;
  
  //First check the absolute minimum and maximum
  if(!IsInM02Range(m02)) return kFALSE ;
  
  //DO NOT USE, study parametrization
  
  //If requested, check the E dependent cuts
  else if(!fUseSimpleM02Cut)
  {
    Int_t inlm = nlm-1;
    if(nlm > 2) inlm=1; // only 2 cases defined nlm=1 and nlm>=2
    
    Float_t minCut = fSplitM02MinCut;
    Float_t maxCut = fSplitM02MaxCut;
    
    Float_t shiftE = energy-20; // to be tuned
    if(nlm==1) shiftE=energy-28;
    
    //e^{a+bx} + c + dx + e/x
    if(shiftE > 1) minCut = TMath::Exp( fM02MinParam[inlm][0] + fM02MinParam[inlm][1]*shiftE ) +
                  fM02MinParam[inlm][2] + fM02MinParam[inlm][3]*shiftE + fM02MinParam[inlm][4]/shiftE;
    
    // In any case the parameter cannot be smaller than 0.3
    if( minCut < fSplitM02MinCut) minCut = fSplitM02MinCut;
    
    shiftE = energy+20; // to be tuned
    
    if(shiftE > 1)  maxCut = 1 + TMath::Exp( fM02MaxParam[inlm][0] + fM02MaxParam[inlm][1]*shiftE ) +
                             fM02MaxParam[inlm][2] + fM02MaxParam[inlm][3]*shiftE + fM02MaxParam[inlm][4]/shiftE;
    
    // In any case the parameter cannot be smaller than 4-5
    if( maxCut > fSplitM02MaxCut) maxCut = fSplitM02MaxCut;
    if( nlm > 2 ) maxCut+=fM02MaxParamShiftNLMN;
    
    //if(energy>6)printf("\t \t E %2.2f, nlm %d, m02 %2.2f, minM02 %2.2f, maxM02 %2.2f\n",energy, nlm, m02,minCut,maxCut);
    
    if(m02 < maxCut && m02 > minCut) return kTRUE;
    else                             return kFALSE;
    
  }
  
  else return kTRUE;
  
}

//______________________________________________________________________________
Bool_t AliCaloPID::IsInConM02Range(Float_t energy, Float_t m02, Int_t nlm) const
{
  // Select the appropriate m02 range in splitting method for converted photons
  // Just min limit for pi0s is max for conversion.
  
  if(!fUseSplitSSCut) return kTRUE ;
  
  Float_t minCut = 0.1;
  Float_t maxCut = fSplitM02MinCut;
  
  if(!fUseSimpleM02Cut)
  {
    Int_t inlm = nlm-1;
    if(nlm > 2) inlm=1; // only 2 cases defined nlm=1 and nlm>=2
    
    //e^{a+bx} + c + dx + e/x
    if(energy > 1) maxCut = TMath::Exp( fM02MinParam[inlm][0] + fM02MinParam[inlm][1]*energy ) +
                            fM02MinParam[inlm][2] + fM02MinParam[inlm][3]*energy + fM02MinParam[inlm][4]/energy;
    
    if( maxCut < fSplitM02MinCut) maxCut = fSplitM02MinCut;
  }
  
  if(m02 < maxCut && m02 > minCut) return kTRUE;
  else                             return kFALSE;
  
}

//______________________________________________
AliEMCALPIDUtils *AliCaloPID::GetEMCALPIDUtils() 
{
  // return pointer to AliEMCALPIDUtils, create it if needed
  
  if(!fEMCALPIDUtils) fEMCALPIDUtils = new AliEMCALPIDUtils ; 
  return fEMCALPIDUtils ; 
  
}


//________________________________________________________________ 
Int_t AliCaloPID::GetIdentifiedParticleType(AliVCluster * cluster)
{
  // Returns a PDG number corresponding to the likely ID of the cluster
  
  Float_t energy  = cluster->E();	
  Float_t lambda0 = cluster->GetM02();
  Float_t lambda1 = cluster->GetM20();
  
  // ---------------------
  // Use bayesian approach
  // ---------------------
  
  if(fUseBayesianWeights)
  {
    Double_t weights[AliPID::kSPECIESCN];
    
    if(cluster->IsEMCAL() && fRecalculateBayesian)
    {	        
      fEMCALPIDUtils->ComputePID(energy, lambda0);
      for(Int_t i = 0; i < AliPID::kSPECIESCN; i++) weights[i] = fEMCALPIDUtils->GetPIDFinal(i);
    }
    else 
    {
      for(Int_t i = 0; i < AliPID::kSPECIESCN; i++) weights[i] = cluster->GetPID()[i];
    }

    if(fDebug > 0)  PrintClusterPIDWeights(weights);
    
    return GetIdentifiedParticleTypeFromBayesWeights(cluster->IsEMCAL(), weights, energy);
  }
  
  // -------------------------------------------------------
  // Calculate PID SS from data, do not use bayesian weights
  // -------------------------------------------------------
  
  AliDebug(1,Form("EMCAL %d?, E %3.2f, l0 %3.2f, l1 %3.2f, disp %3.2f, tof %1.11f, distCPV %3.2f, distToBC %1.1f, NMax %d",
                  cluster->IsEMCAL(),energy,lambda0,cluster->GetM20(),cluster->GetDispersion(),cluster->GetTOF(),
                  cluster->GetEmcCpvDistance(), cluster->GetDistanceToBadChannel(),cluster->GetNExMax()));
  
  if(cluster->IsEMCAL())
  {
    AliDebug(1,Form("EMCAL SS %f <%f < %f?",fEMCALL0CutMin, lambda0, fEMCALL0CutMax));
    
    if(lambda0 < fEMCALL0CutMax && lambda0 > fEMCALL0CutMin) return kPhoton ;
    else                                                     return kNeutralUnknown ; 
  }    // EMCAL
  else // PHOS
  {    
    if(TestPHOSDispersion(energy,lambda0,lambda1) < fPHOSDispersionCut) return kPhoton;
    else                                                                return kNeutralUnknown;
  }
  
}

//_________________________________________________________________________________________________________
Int_t AliCaloPID::GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy)
{
  //Return most probable identity of the particle after bayesian weights calculated in reconstruction
  
  if(!pid)
  { 
    AliFatal("pid pointer not initialized!!!");
    return kNeutralUnknown; // not needed, added to content coverity
  }
  
  Float_t wPh  =  fPHOSPhotonWeight ;
  Float_t wPi0 =  fPHOSPi0Weight ;
  Float_t wE   =  fPHOSElectronWeight ;
  Float_t wCh  =  fPHOSChargeWeight ;
  Float_t wNe  =  fPHOSNeutralWeight ;
  
  if(!isEMCAL && fPHOSWeightFormula){
    wPh  = GetPHOSPhotonWeightFormula()->Eval(energy) ;
    wPi0 = GetPHOSPi0WeightFormula()   ->Eval(energy);
  }
  else
  {
    wPh  =  fEMCALPhotonWeight ;
    wPi0 =  fEMCALPi0Weight ;
    wE   =  fEMCALElectronWeight ;
    wCh  =  fEMCALChargeWeight ;
    wNe  =  fEMCALNeutralWeight ;
  }
  
  if(fDebug > 0) PrintClusterPIDWeights(pid);
    
  Int_t pdg = kNeutralUnknown ;
  Float_t chargedHadronWeight = pid[AliVCluster::kProton]+pid[AliVCluster::kKaon]+
  pid[AliVCluster::kPion]+pid[AliVCluster::kMuon];
  Float_t neutralHadronWeight = pid[AliVCluster::kNeutron]+pid[AliVCluster::kKaon0];
  Float_t allChargedWeight    = pid[AliVCluster::kElectron]+pid[AliVCluster::kEleCon]+ chargedHadronWeight;
  Float_t allNeutralWeight    = pid[AliVCluster::kPhoton]+pid[AliVCluster::kPi0]+ neutralHadronWeight;
  
  //Select most probable ID
  if(!isEMCAL) // PHOS
  {
    if(pid[AliVCluster::kPhoton] > wPh)        pdg = kPhoton ;
    else if(pid[AliVCluster::kPi0] > wPi0)     pdg = kPi0 ; 
    else if(pid[AliVCluster::kElectron] > wE)  pdg = kElectron ;
    else if(pid[AliVCluster::kEleCon] >  wE)   pdg = kEleCon ;
    else if(chargedHadronWeight > wCh)         pdg = kChargedHadron ;  
    else if(neutralHadronWeight > wNe)         pdg = kNeutralHadron ; 
    else if(allChargedWeight >  allNeutralWeight)
      pdg = kChargedUnknown ; 
    else 
      pdg = kNeutralUnknown ;
  }
  else //EMCAL
  {
    if(pid[AliVCluster::kPhoton]  > wPh)                     pdg = kPhoton ;
    else if(pid[AliVCluster::kElectron]  > wE)               pdg = kElectron ;
    else if(pid[AliVCluster::kPhoton]+pid[AliVCluster::kElectron]  > wPh) pdg = kPhoton ; //temporal sollution until track matching for electrons is considered
    else if(pid[AliVCluster::kPi0] > wPi0)                   pdg = kPi0 ; 
    else if(chargedHadronWeight + neutralHadronWeight > wCh) pdg = kChargedHadron ;  
    else if(neutralHadronWeight + chargedHadronWeight > wNe) pdg = kNeutralHadron ; 
    else                                                     pdg = kNeutralUnknown ;
  }
  
  AliDebug(1,Form("Final Pdg: %d, cluster energy %2.2f", pdg,energy));

  return pdg ;
  
}

//____________________________________________________________________________________________________________
Int_t AliCaloPID::GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster* cluster, 
                                                                AliVCaloCells* cells,
                                                                AliCalorimeterUtils * caloutils,
                                                                Double_t   vertex[3],
                                                                Int_t    & nMax,
                                                                Double_t & mass,   Double_t & angle,
                                                                TLorentzVector & l1, TLorentzVector & l2,
                                                                Int_t   & absId1,   Int_t   & absId2,
                                                                Float_t & distbad1, Float_t & distbad2,
                                                                Bool_t  & fidcut1,  Bool_t  & fidcut2  ) const
{
  // Split the cluster in 2, do invariant mass, get the mass and decide 
  // if this is a photon, pi0, eta, ...
  
  Float_t eClus  = cluster->E();
  Float_t m02    = cluster->GetM02();
  const Int_t nc = cluster->GetNCells();
  Int_t   absIdList[nc]; 
  Float_t maxEList [nc];
  
  mass  = -1.;
  angle = -1.;
  
  //If too low number of cells, skip it
  if ( nc < fSplitMinNCells)  return kNeutralUnknown ; 
  
  AliDebug(2,"\t pass nCells cut");
  
  // Get Number of local maxima
  nMax  = caloutils->GetNumberOfLocalMaxima(cluster, cells, absIdList, maxEList) ; 
  
  AliDebug(1,Form("Cluster : E %1.1f, M02 %1.2f, NLM %d, N Cells %d",eClus,m02,nMax,nc));

  //---------------------------------------------------------------------
  // Get the 2 max indeces and do inv mass
  //---------------------------------------------------------------------
  
  Int_t  calorimeter = AliCalorimeterUtils::kEMCAL;
  if(cluster->IsPHOS()) calorimeter = AliCalorimeterUtils::kPHOS;

  if     ( nMax == 2 )
  {
    absId1 = absIdList[0];
    absId2 = absIdList[1];
    
    //Order in energy
    Float_t en1 = cells->GetCellAmplitude(absId1);
    caloutils->RecalibrateCellAmplitude(en1,calorimeter,absId1);
    Float_t en2 = cells->GetCellAmplitude(absId2);
    caloutils->RecalibrateCellAmplitude(en2,calorimeter,absId2);
    if(en1 < en2)
    {
      absId2 = absIdList[0];
      absId1 = absIdList[1];
    }
  }
  else if( nMax == 1 )
  {
    
    absId1 = absIdList[0];
    
    //Find second highest energy cell
    
    Float_t enmax = 0 ;
    for(Int_t iDigit = 0 ; iDigit < cluster->GetNCells() ; iDigit++)
    {
      Int_t absId = cluster->GetCellsAbsId()[iDigit];
      if( absId == absId1 ) continue ; 
      Float_t endig = cells->GetCellAmplitude(absId);
      caloutils->RecalibrateCellAmplitude(endig,calorimeter,absId); 
      if(endig > enmax) 
      {
        enmax  = endig ;
        absId2 = absId ;
      }
    }// cell loop
  }// 1 maxima 
  else
  {  // n max > 2
    // loop on maxima, find 2 highest
    
    // First max
    Float_t enmax = 0 ;
    for(Int_t iDigit = 0 ; iDigit < nMax ; iDigit++)
    {
      Float_t endig = maxEList[iDigit];
      if(endig > enmax) 
      {
        enmax  = endig ;
        absId1 = absIdList[iDigit];
      }
    }// first maxima loop
    
    // Second max 
    Float_t enmax2 = 0;
    for(Int_t iDigit = 0 ; iDigit < nMax ; iDigit++)
    {
      if(absIdList[iDigit]==absId1) continue;
      Float_t endig = maxEList[iDigit];
      if(endig > enmax2) 
      {
        enmax2  = endig ;
        absId2 = absIdList[iDigit];
      }
    }// second maxima loop
    
  } // n local maxima > 2
  
  if(absId2<0 || absId1<0) 
  {
    AliDebug(1,Form("Bad index for local maxima : N max %d, i1 %d, i2 %d, cluster E %2.2f, ncells %d, m02 %2.2f",
                    nMax,absId1,absId2,eClus,nc,m02));
    return kNeutralUnknown ;
  }
  
  //---------------------------------------------------------------------
  // Split the cluster energy in 2, around the highest 2 local maxima
  //---------------------------------------------------------------------  
  
  AliAODCaloCluster cluster1(0, 0,NULL,0.,NULL,NULL,1,0);
  AliAODCaloCluster cluster2(1, 0,NULL,0.,NULL,NULL,1,0);
  
  caloutils->SplitEnergy(absId1,absId2,cluster, cells, &cluster1, &cluster2,nMax); /*absIdList, maxEList,*/
  
  fidcut1 = caloutils->GetEMCALRecoUtils()->CheckCellFiducialRegion(caloutils->GetEMCALGeometry(), &cluster1,cells);
  fidcut2 = caloutils->GetEMCALRecoUtils()->CheckCellFiducialRegion(caloutils->GetEMCALGeometry(), &cluster2,cells);

  caloutils->GetEMCALRecoUtils()->RecalculateClusterDistanceToBadChannel(caloutils->GetEMCALGeometry(),cells,&cluster1);
  caloutils->GetEMCALRecoUtils()->RecalculateClusterDistanceToBadChannel(caloutils->GetEMCALGeometry(),cells,&cluster2);

  distbad1 = cluster1.GetDistanceToBadChannel();
  distbad2 = cluster2.GetDistanceToBadChannel();
//  if(!fidcut2 || !fidcut1 || distbad1 < 2 || distbad2 < 2)
//    printf("*** Dist to bad channel cl %f, cl1 %f, cl2 %f; fid cut cl %d, cl1 %d, cl2 %d \n",
//           cluster->GetDistanceToBadChannel(),distbad1,distbad2,
//           caloutils->GetEMCALRecoUtils()->CheckCellFiducialRegion(caloutils->GetEMCALGeometry(), cluster,cells),fidcut1,fidcut2);
  
  cluster1.GetMomentum(l1,vertex);
  cluster2.GetMomentum(l2,vertex);
  
  mass  = (l1+l2).M();
  angle = l2.Angle(l1.Vect());
  Float_t e1 = cluster1.E();
  Float_t e2 = cluster2.E();
  
  // Consider clusters with splitted energy not too different to original cluster energy
  Float_t splitFracCut = 0;
  if(nMax < 3)  splitFracCut = fSplitEFracMin[nMax-1];
  else          splitFracCut = fSplitEFracMin[2];
  if((e1+e2)/eClus < splitFracCut) return kNeutralUnknown ;

  AliDebug(2,"\t pass Split E frac cut");
  
  // Consider sub-clusters with minimum energy
  Float_t minECut = fSubClusterEMin[2];
  if     (nMax == 2)  minECut = fSubClusterEMin[1];
  else if(nMax == 1)  minECut = fSubClusterEMin[0];
  if(e1 < minECut || e2 < minECut)
  {
    //printf("Reject: e1 %2.1f, e2 %2.1f, cut %2.1f\n",e1,e2,minECut);
    return kNeutralUnknown ;
  }

  AliDebug(2,"\t pass min sub-cluster E cut");
  
  // Asymmetry of cluster
  Float_t asy =-10;
  if(e1+e2 > 0) asy = (e1-e2) / (e1+e2);

  if( !IsInPi0SplitAsymmetryRange(eClus,asy,nMax) ) return kNeutralUnknown ;
  
  
  AliDebug(2,"\t pass asymmetry cut");
  
  Bool_t pi0OK = kFALSE;
  Bool_t etaOK = kFALSE;
  Bool_t conOK = kFALSE;
  
  //If too small or big M02, skip it
  if     (IsInPi0M02Range(eClus,m02,nMax))  pi0OK = kTRUE;
  else if(IsInEtaM02Range(eClus,m02,nMax))  etaOK = kTRUE;
  else if(IsInConM02Range(eClus,m02,nMax))  conOK = kTRUE;
  
  Float_t energy = eClus;
  if(nMax > 2) energy = e1+e2; // In case of NLM>2 use mass cut for NLM=2 but for the split sum not the cluster energy that is not the pi0 E.
  
  // Check the mass, and set an ID to the splitted cluster
  if     ( conOK && mass < fMassPhoMax && mass > fMassPhoMin ) { AliDebug(2,"\t Split Conv"); return kPhoton ; }
  else if( etaOK && mass < fMassEtaMax && mass > fMassEtaMin ) { AliDebug(2,"\t Split Eta" ); return kEta    ; }
  else if( pi0OK && IsInPi0SplitMassRange(energy,mass,nMax)  ) { AliDebug(2,"\t Split Pi0" ); return kPi0    ; }
  else                                                                                        return kNeutralUnknown ;
  
}

//_________________________________________
TString  AliCaloPID::GetPIDParametersList()  
{
  //Put data member values in string to keep in output container
  
  TString parList ; //this will be list of parameters used for this analysis.
  const Int_t buffersize = 255;
  char onePar[buffersize] ;
  snprintf(onePar,buffersize,"--- AliCaloPID ---") ;
  parList+=onePar ;	
  if(fUseBayesianWeights)
  {
    snprintf(onePar,buffersize,"fEMCALPhotonWeight =%2.2f (EMCAL bayesian weight for photons)",fEMCALPhotonWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fEMCALPi0Weight =%2.2f (EMCAL bayesian weight for pi0)",fEMCALPi0Weight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fEMCALElectronWeight =%2.2f(EMCAL bayesian weight for electrons)",fEMCALElectronWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fEMCALChargeWeight =%2.2f (EMCAL bayesian weight for charged hadrons)",fEMCALChargeWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fEMCALNeutralWeight =%2.2f (EMCAL bayesian weight for neutral hadrons)",fEMCALNeutralWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fPHOSPhotonWeight =%2.2f (PHOS bayesian weight for photons)",fPHOSPhotonWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fPHOSPi0Weight =%2.2f (PHOS bayesian weight for pi0)",fPHOSPi0Weight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fPHOSElectronWeight =%2.2f(PHOS bayesian weight for electrons)",fPHOSElectronWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fPHOSChargeWeight =%2.2f (PHOS bayesian weight for charged hadrons)",fPHOSChargeWeight) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fPHOSNeutralWeight =%2.2f (PHOS bayesian weight for neutral hadrons)",fPHOSNeutralWeight) ;
    parList+=onePar ;
    
    if(fPHOSWeightFormula)
    {
      snprintf(onePar,buffersize,"PHOS Photon Weight Formula: %s",fPHOSPhotonWeightFormulaExpression.Data() ) ;
      parList+=onePar;
      snprintf(onePar,buffersize,"PHOS Pi0    Weight Formula: %s",fPHOSPi0WeightFormulaExpression.Data()    ) ;
      parList+=onePar;	  
    }
  }
  else
  {
    snprintf(onePar,buffersize,"EMCAL: fEMCALL0CutMin =%2.2f, fEMCALL0CutMax =%2.2f  (Cut on Shower Shape)",fEMCALL0CutMin, fEMCALL0CutMax) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"EMCAL: fEMCALDEtaCut =%2.2f, fEMCALDPhiCut =%2.2f  (Cut on track matching)",fEMCALDEtaCut, fEMCALDPhiCut) ;
    parList+=onePar ;
    snprintf(onePar,buffersize,"fTOFCut  =%e (Cut on TOF, used in PID evaluation)",fTOFCut) ;
    parList+=onePar ;	
    snprintf(onePar,buffersize,"fPHOSRCut =%2.2f, fPHOSDispersionCut =%2.2f  (Cut on Shower Shape and CPV)",fPHOSRCut,fPHOSDispersionCut) ;
    parList+=onePar ;
    
  }
  
  if(fUseSimpleM02Cut)
  {
    snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f",    fSplitM02MinCut, fSplitM02MaxCut) ;
    parList+=onePar ;
  }
  snprintf(onePar,buffersize,"fMinNCells =%d",        fSplitMinNCells) ;
  parList+=onePar ;
  if(fUseSimpleMassCut)
  {
    snprintf(onePar,buffersize,"pi0 : %2.1f < m <%2.1f", fMassPi0Min,fMassPi0Max);
    parList+=onePar ;
  }
  snprintf(onePar,buffersize,"eta : %2.1f < m <%2.1f", fMassEtaMin,fMassEtaMax);
  parList+=onePar ;
  snprintf(onePar,buffersize,"conv: %2.1f < m <%2.1f", fMassPhoMin,fMassPhoMax);
  parList+=onePar ;
  
  
  return parList;
  
}

//________________________________________________
void AliCaloPID::Print(const Option_t * opt) const
{
  
  //Print some relevant parameters set for the analysis
  if(! opt)
    return;
  
  printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
  
  if(fUseBayesianWeights)
  {
    printf("PHOS PID weight , photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f \n",  
           fPHOSPhotonWeight,   fPHOSPi0Weight, 
           fPHOSElectronWeight, fPHOSChargeWeight, fPHOSNeutralWeight) ; 
    printf("EMCAL PID weight, photon %0.2f, pi0 %0.2f, e %0.2f, charge %0.2f, neutral %0.2f\n",   
           fEMCALPhotonWeight,   fEMCALPi0Weight, 
           fEMCALElectronWeight, fEMCALChargeWeight, fEMCALNeutralWeight) ; 
    
    printf("PHOS Parametrized weight on?  =     %d\n",  fPHOSWeightFormula) ; 
    if(fPHOSWeightFormula)
    {
      printf("Photon weight formula = %s\n", fPHOSPhotonWeightFormulaExpression.Data());
      printf("Pi0    weight formula = %s\n", fPHOSPi0WeightFormulaExpression   .Data());
    }
    if(fRecalculateBayesian) printf(" Recalculate bayesian with Particle Flux?    = %d\n",fParticleFlux);
  }
  else 
  {
    printf("TOF cut        = %e\n",                                   fTOFCut);
    printf("EMCAL Lambda0 cut min = %2.2f; max = %2.2f\n",            fEMCALL0CutMin,fEMCALL0CutMax);
    printf("EMCAL cluster-track dEta < %2.3f; dPhi < %2.3f\n",        fEMCALDEtaCut, fEMCALDPhiCut);
    printf("PHOS Treac matching cut =%2.2f, Dispersion Cut =%2.2f \n",fPHOSRCut,     fPHOSDispersionCut) ;
    
  }
  
  printf("Min. N Cells =%d \n",         fSplitMinNCells) ;
  if(fUseSimpleM02Cut) printf("%2.2f < lambda_0^2 <%2.2f \n",fSplitM02MinCut,fSplitM02MaxCut);
  if(fUseSimpleMassCut)printf("pi0 : %2.2f<m<%2.2f \n",      fMassPi0Min,fMassPi0Max);
  printf("eta : %2.2f<m<%2.2f \n",      fMassEtaMin,fMassEtaMax);
  printf("phot: %2.2f<m<%2.2f \n",      fMassPhoMin,fMassPhoMax);
  
  printf(" \n");
  
} 

//_________________________________________________________________
void AliCaloPID::PrintClusterPIDWeights(const Double_t * pid) const
{
  // print PID of cluster, (AliVCluster*)cluster->GetPID()
  
  printf("AliCaloPID::PrintClusterPIDWeights() \n \t ph %0.2f, pi0 %0.2f, el %0.2f, conv el %0.2f, \n \t \
         pion %0.2f, kaon %0.2f, proton %0.2f , neutron %0.2f, kaon %0.2f \n",
         pid[AliVCluster::kPhoton],    pid[AliVCluster::kPi0],
         pid[AliVCluster::kElectron],  pid[AliVCluster::kEleCon],
         pid[AliVCluster::kPion],      pid[AliVCluster::kKaon], 
         pid[AliVCluster::kProton],
         pid[AliVCluster::kNeutron],   pid[AliVCluster::kKaon0]);
  
}

//___________________________________________________________________________
void AliCaloPID::SetPIDBits(AliVCluster * cluster, 
                            AliAODPWG4Particle * ph, AliCalorimeterUtils* cu, 
                            AliVEvent* event) 
{
  //Set Bits for PID selection
  
  //Dispersion/lambdas
  //Double_t disp= cluster->GetDispersion()  ;
  Double_t l1  = cluster->GetM20() ;
  Double_t l0  = cluster->GetM02() ; 
  Bool_t isDispOK = kTRUE ;
  if(cluster->IsPHOS()){ 
    if(TestPHOSDispersion(ph->Pt(),l0,l1) < fPHOSDispersionCut) isDispOK = kTRUE;
    else                                                        isDispOK = kFALSE; 
  }
  else{//EMCAL
    
    if(l0 > fEMCALL0CutMin && l0 < fEMCALL0CutMax) isDispOK = kTRUE;

  }
  
  ph->SetDispBit(isDispOK) ;
  
  //TOF
  Double_t tof=cluster->GetTOF()  ;
  ph->SetTOFBit(TMath::Abs(tof)<fTOFCut) ; 
  
  //Charged 
  Bool_t isNeutral = IsTrackMatched(cluster,cu,event);
  
  ph->SetChargedBit(isNeutral);
  
  //Set PID pdg
  ph->SetIdentifiedParticleType(GetIdentifiedParticleType(cluster));
 
  AliDebug(1,Form("TOF %e, Lambda0 %2.2f, Lambda1 %2.2f",tof , l0, l1));
  AliDebug(1,Form("pdg %d, bits: TOF %d, Dispersion %d, Charge %d",
           ph->GetIdentifiedParticleType(), ph->GetTOFBit() , ph->GetDispBit() , ph->GetChargedBit()));
}

//_________________________________________________________
Bool_t AliCaloPID::IsTrackMatched(AliVCluster* cluster,
                                  AliCalorimeterUtils * cu,
                                  AliVEvent* event) const
{
  //Check if there is any track attached to this cluster
  
  Int_t nMatches = cluster->GetNTracksMatched();
  AliVTrack * track = 0;
  
  if(nMatches > 0)
  {
    //In case of ESDs, by default without match one entry with negative index, no match, reject.
    if(!strcmp("AliESDCaloCluster",Form("%s",cluster->ClassName())))
    {
      Int_t iESDtrack = cluster->GetTrackMatchedIndex();
      if(iESDtrack >= 0) track = dynamic_cast<AliVTrack*> (event->GetTrack(iESDtrack));
      else return kFALSE;
      
      if (!track)
      {
        AliWarning("Null matched track in ESD when index is OK!");
        return kFALSE;
      }
    }
    else
    { // AOD
      track = dynamic_cast<AliVTrack*> (cluster->GetTrackMatched(0));
      if (!track)
      {
        AliWarning("Null matched track in AOD!");
        return kFALSE;
      }
    }
    
    Float_t dZ  = cluster->GetTrackDz();
    Float_t dR  = cluster->GetTrackDx();
    
    // if track matching was recalculated
    if(cluster->IsEMCAL() && cu && cu->IsRecalculationOfClusterTrackMatchingOn())
    {
      dR = 2000., dZ = 2000.;
      cu->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
    }
    
    if(cluster->IsPHOS())
    {
      Int_t charge = track->Charge();
      Double_t mf  = event->GetMagneticField();
      if(TestPHOSChargedVeto(dR, dZ, track->Pt(), charge, mf ) < fPHOSRCut) return kTRUE;
      else                                                                  return kFALSE;
      
    }//PHOS
    else //EMCAL
    {
      
      AliDebug(1,Form("EMCAL dR %f < %f, dZ %f < %f ",dR, fEMCALDPhiCut, dZ, fEMCALDEtaCut));
      
      if(TMath::Abs(dR) < fEMCALDPhiCut &&
         TMath::Abs(dZ) < fEMCALDEtaCut)   return kTRUE;
      else                                 return kFALSE;
      
    }//EMCAL cluster
    
    
  } // more than 1 match, at least one track in array
  else return kFALSE;
  
}

//___________________________________________________________________________________________________
Float_t AliCaloPID::TestPHOSDispersion(const Double_t pt, const Double_t l1, const Double_t l2) const
{
  //Check if cluster photon-like. Uses photon cluster parameterization in real pp data
  //Returns distance in sigmas. Recommended cut 2.5
  
  Double_t l2Mean  = 1.53126+9.50835e+06/(1.+1.08728e+07*pt+1.73420e+06*pt*pt) ;
  Double_t l1Mean  = 1.12365+0.123770*TMath::Exp(-pt*0.246551)+5.30000e-03*pt ;
  Double_t l2Sigma = 6.48260e-02+7.60261e+10/(1.+1.53012e+11*pt+5.01265e+05*pt*pt)+9.00000e-03*pt;
  Double_t l1Sigma = 4.44719e-04+6.99839e-01/(1.+1.22497e+00*pt+6.78604e-07*pt*pt)+9.00000e-03*pt;
  Double_t c       =-0.35-0.550*TMath::Exp(-0.390730*pt) ;
  Double_t r2      = 0.5*  (l1-l1Mean)*(l1-l1Mean)/l1Sigma/l1Sigma +
  0.5*  (l2-l2Mean)*(l2-l2Mean)/l2Sigma/l2Sigma +
  0.5*c*(l1-l1Mean)*(l2-l2Mean)/l1Sigma/l2Sigma ;
  
  AliDebug(1,Form("PHOS SS R %f < %f?", TMath::Sqrt(r2), fPHOSDispersionCut));
  
  return TMath::Sqrt(r2) ;
  
}

//_______________________________________________________________________________________________
Float_t AliCaloPID::TestPHOSChargedVeto(const Double_t dx,  const Double_t dz, const Double_t pt, 
                                        const Int_t charge, const Double_t mf) const 
{
  //Checks distance to the closest track. Takes into account 
  //non-perpendicular incidence of tracks.
  //returns distance in sigmas. Recommended cut: 2.
  //Requires (sign) of magnetic filed. onc can find it for example as following
  //  Double_t mf=0. ;
  //  AliESDEvent *event = dynamic_cast<AliESDEvent*>(InputEvent());
  //  if(event)
  //    mf = event->GetMagneticField(); //Positive for ++ and negative for --
  
  
  Double_t meanX = 0.;
  Double_t meanZ = 0.;
  Double_t sx = TMath::Min(5.4,2.59719e+02*TMath::Exp(-pt/1.02053e-01)+
                           6.58365e-01*5.91917e-01*5.91917e-01/((pt-9.61306e-01)*(pt-9.61306e-01)+5.91917e-01*5.91917e-01)+
                           1.59219);
  Double_t sz = TMath::Min(2.75,4.90341e+02*1.91456e-02*1.91456e-02/(pt*pt+1.91456e-02*1.91456e-02)+
                           1.60) ;
  
  if(mf<0.){ //field --
    meanZ = -0.468318 ;
    if(charge>0)
      meanX = TMath::Min(7.3, 3.89994*1.20679 *1.20679 /(pt*pt+1.20679*1.20679)+  
                         0.249029+2.49088e+07*TMath::Exp(-pt*3.33650e+01)) ;
    else
      meanX =-TMath::Min(7.7, 3.86040*0.912499*0.912499/(pt*pt+0.912499*0.912499)+
                         1.23114 +4.48277e+05*TMath::Exp(-pt*2.57070e+01)) ;
  }
  else{ //Field ++
    meanZ = -0.468318;
    if(charge>0)
      meanX =-TMath::Min(8.0,3.86040*1.31357*1.31357/(pt*pt+1.31357*1.31357)+
                         0.880579+7.56199e+06*TMath::Exp(-pt*3.08451e+01)) ;
    else
      meanX = TMath::Min(6.85, 3.89994*1.16240*1.16240/(pt*pt+1.16240*1.16240)-
                         0.120787+2.20275e+05*TMath::Exp(-pt*2.40913e+01)) ;     
  }
  
  Double_t rz = (dz-meanZ)/sz ;
  Double_t rx = (dx-meanX)/sx ;
  
  AliDebug(1,Form("PHOS Matching R %f < %f",TMath::Sqrt(rx*rx+rz*rz), fPHOSRCut));
  
  return TMath::Sqrt(rx*rx+rz*rz) ;
  
}

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