AliAnaParticleIsolation.h

Go to the documentation of this file.

#ifndef ALIANAPARTICLEISOLATION_H
#define ALIANAPARTICLEISOLATION_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */

//_________________________________________________________________________

// --- ROOT system ---
class TH2F;
class TList ;
class TObjString;

// --- ANALYSIS system ---
#include "AliAnaCaloTrackCorrBaseClass.h"
class AliAODPWG4Particle;
class AliAODPWG4ParticleCorrelation ;

class AliAnaParticleIsolation : public AliAnaCaloTrackCorrBaseClass {

 public:
    
  AliAnaParticleIsolation() ;
    
  virtual ~AliAnaParticleIsolation() { ; }

  // Main general methods
    
  void         CalculateCaloUEBand    (AliAODPWG4ParticleCorrelation * pCandidate,
                                       Float_t & etaBand, Float_t & phiBand) ;
    
  void         CalculateCaloCellUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
                                       Float_t & etaBand, Float_t & phiBand) ;
    
  void         CalculateTrackUEBand   (AliAODPWG4ParticleCorrelation * pCandidate,
                                       Float_t & etaBand, Float_t & phiBand) ;
  
  void         CalculateCaloSignalInCone    (AliAODPWG4ParticleCorrelation * aodParticle, Float_t & coneptsumCluster, Float_t & coneptLeadCluster) ;
    
  void         CalculateCaloCellSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle, Float_t & coneptsumCell) ;

  void         CalculateTrackSignalInCone   (AliAODPWG4ParticleCorrelation * aodParticle, Float_t & coneptsumTrack  , Float_t & coneptLeadTrack  ) ;


  void         CalculateNormalizeUEBandPerUnitArea(AliAODPWG4ParticleCorrelation * pCandidate,
                                                   Float_t coneptsumCluster,       Float_t coneptsumCell,     Float_t coneptsumTrack,
                                                   Float_t &etaBandptsumTrackNorm, Float_t &etaBandptsumClusterNorm ) ;
  
  TObjString * GetAnalysisCuts() ;
  
  TList      * GetCreateOutputObjects() ;
  
  void         Init() ;

  void         InitParameters() ;
  
  void         MakeAnalysisFillAOD()  ;
  
  void         MakeAnalysisFillHistograms() ;
  
  void         Print( const Option_t * opt ) const ;
 
  // Analysis specific methods
  
  void         FillPileUpHistograms(Float_t energy, Float_t time) ; //Int_t clusterID) ;
  
  void         FillAcceptanceHistograms();
 
  void         FillTrackMatchingShowerShapeControlHistograms(AliAODPWG4ParticleCorrelation  * pCandidate,
                                                             Float_t coneptsum, Float_t coneleadpt, Int_t mcIndex) ;
  
  Bool_t       IsTriggerTheNearSideEventLeadingParticle(Int_t & idLeading);
  
  void         MakeSeveralICAnalysis( AliAODPWG4ParticleCorrelation * ph, Int_t mcIndex ) ;
  
  // Analysis Setters and Getters
  
  TString      GetTriggerDetectorString()      const { return fIsoDetectorString ; }
  TString      GetTriggerDetector()            const { return fIsoDetector       ; }
  Int_t        GetNCones()                     const { return fNCones            ; }
  Int_t        GetNPtThresFrac()               const { return fNPtThresFrac      ; }
  Float_t      GetConeSizes(Int_t i)           const { return fConeSizes[i]      ; }
  Float_t      GetPtThresholds(Int_t i)        const { return fPtThresholds[i]   ; }
  Float_t      GetSumPtThresholds(Int_t i)     const { return fSumPtThresholds[i]; }
  Float_t      GetPtFractions(Int_t i)         const { return fPtFractions[i]    ; }
  
  Int_t        GetMCIndex(Int_t mcTag);
  
  void         SetTriggerDetector(TString & det)     ;
  void         SetTriggerDetector(Int_t  det)        ;
  void         SetNCones(Int_t ncs)                  { fNCones          = ncs    ; }
  void         SetNPtThresFrac(Int_t npt)            { fNPtThresFrac    = npt    ; }
  void         SetConeSizes(Int_t i, Float_t r)      { fConeSizes[i]    = r      ; }
  void         SetPtThresholds(Int_t i, Float_t pt)  { fPtThresholds[i] = pt     ; }
  void         SetPtFractions(Int_t i, Float_t pt)   { fPtFractions[i]  = pt     ; } 
  void         SetSumPtThresholds(Int_t i, Float_t pt){ fSumPtThresholds[i] = pt ; }

  void         SetMinCellsAngleOverlap(Float_t n)    { fMinCellsAngleOverlap = n ; }
  
  Bool_t       IsReIsolationOn()               const { return fReMakeIC          ; }
  void         SwitchOnReIsolation()                 { fReMakeIC      = kTRUE    ; }
  void         SwitchOffReIsolation()                { fReMakeIC      = kFALSE   ; }
  
  Bool_t       IsSeveralIsolationOn()          const { return fMakeSeveralIC     ; }
  void         SwitchOnSeveralIsolation()            { fMakeSeveralIC = kTRUE    ; }
  void         SwitchOffSeveralIsolation()           { fMakeSeveralIC = kFALSE   ; }
  
  void         SwitchOnTMHistoFill()                 { fFillTMHisto   = kTRUE    ; }
  void         SwitchOffTMHistoFill()                { fFillTMHisto   = kFALSE   ; }
  
  void         SwitchOnSSHistoFill()                 { fFillSSHisto   = kTRUE    ; }
  void         SwitchOffSSHistoFill()                { fFillSSHisto   = kFALSE   ; }

  void         SwitchOnFillEMCALRegionSSHistograms() { fFillEMCALRegionSSHistograms = kTRUE  ; }
  void         SwitchOffFillEMCALRegionSSHistograms(){ fFillEMCALRegionSSHistograms = kFALSE ; }  
  
  Bool_t       IsLeadingOnlyOn()               const { return fLeadingOnly       ; }
  void         SwitchOnLeadingOnly()                 { fLeadingOnly    = kTRUE   ; }
  void         SwitchOffLeadingOnly()                { fLeadingOnly    = kFALSE  ; }
  
  void         SwitchOnCheckNeutralClustersForLeading() { fCheckLeadingWithNeutralClusters = kTRUE  ; }
  void         SwitchOffCheckNeutralClustersForLeading(){ fCheckLeadingWithNeutralClusters = kFALSE ; }
  
  void         SwitchOnUEBandSubtractionHistoFill()  { fFillUEBandSubtractHistograms   = kTRUE    ; }
  void         SwitchOffUEBandSubtractionHistoFill() { fFillUEBandSubtractHistograms   = kFALSE   ; }

  void         SwitchOnCellHistoFill()               { fFillCellHistograms = kTRUE ; }
  void         SwitchOffCellHistoFill()              { fFillCellHistograms = kFALSE; }

  void         SwitchOnNLMHistoFill()                { fFillNLMHistograms = kTRUE ; }
  void         SwitchOffNLMHistoFill()               { fFillNLMHistograms = kFALSE; }
  
  void         SwitchOnDecayTaggedHistoFill()        { fFillTaggedDecayHistograms = kTRUE ; }
  void         SwitchOffDecayTaggedHistoFill()       { fFillTaggedDecayHistograms = kFALSE; }
  void         SetNDecayBits(Int_t n)                { fNDecayBits = n               ; }
  void         SetDecayBits(Int_t i, UInt_t bit)     { if(i < AliNeutralMesonSelection::fgkMaxNDecayBits)
                                                       fDecayBits[i] = bit           ; }
  void         SetM02CutForTaggedDecays(Float_t m02) { fDecayTagsM02Cut        = m02 ; }
  
  void         SwitchOnBackgroundBinHistoFill()      { fFillBackgroundBinHistograms = kTRUE ; }
  void         SwitchOffBackgroundBinHistoFill()     { fFillBackgroundBinHistograms = kFALSE; }
  void         SetNBackgroundBins(Int_t n)           { if(n < 19) fNBkgBin = n ; }
  void         SetBackgroundLimits(Int_t i,Float_t l){ if(i <= fNBkgBin) fBkgBinLimit[i] = l; }

  void         SwitchOnPtTrigBinHistoFill()          { fFillPtTrigBinHistograms = kTRUE ; }
  void         SwitchOffPtTrigBinHistoFill()         { fFillPtTrigBinHistograms = kFALSE; }
  void         SetNPtTrigBins(Int_t n)               { if(n < 19) fNPtTrigBin = n ; }
  void         SetPtTrigLimits(Int_t i,Float_t l)    { if(i <= fNPtTrigBin) fPtTrigBinLimit[i] = l; }

  void         SwitchOnPrimariesInConeSelection()    { fSelectPrimariesInCone = kTRUE ; }
  void         SwitchOffPrimariesInConeSelection()   { fSelectPrimariesInCone = kFALSE; }

  void         SwitchOnPrimariesPi0DecayStudy()      { fMakePrimaryPi0DecayStudy = kTRUE ; }
  void         SwitchOffPrimariesPi0DecayStudy()     { fMakePrimaryPi0DecayStudy = kFALSE; }
  
  void         SwitchOnOverlapHistograms()           { fFillOverlapHistograms = kTRUE ; }
  void         SwitchOffOverlapHistograms()          { fFillOverlapHistograms = kFALSE; }
  
  enum mcPrimTypes { kmcPrimPhoton = 0, kmcPrimPi0Decay = 1, kmcPrimEtaDecay  = 2, kmcPrimOtherDecay  = 3,
                     kmcPrimPrompt = 4, kmcPrimFrag     = 5, kmcPrimISR       = 6,
                     kmcPrimPi0    = 7, kmcPrimEta      = 8                                               } ;
  
  static const Int_t fgkNmcPrimTypes = 9; 
  
  enum mcTypes     { kmcPhoton   = 0, kmcPrompt     = 1, kmcFragment         = 2,
                     kmcPi0      = 3, kmcPi0Decay   = 4, kmcPi0DecayLostPair = 5,
                     kmcEta      = 6, kmcEtaDecay   = 7, kmcEtaDecayLostPair = 8,
                     kmcOtherDecay=9, kmcElectron   =10, kmcHadron           =11  } ;
  
  static const Int_t fgkNmcTypes = 12; 

 private:
  
  Int_t    fIsoDetector ;                             
  TString  fIsoDetectorString ;                       
  Bool_t   fReMakeIC ;                                
  Bool_t   fMakeSeveralIC ;                           
  Bool_t   fFillTMHisto;                              
  Bool_t   fFillSSHisto;                              
  Bool_t   fFillEMCALRegionSSHistograms ;             
  Bool_t   fFillUEBandSubtractHistograms;             
  Bool_t   fFillCellHistograms;                       
  Bool_t   fFillOverlapHistograms;                    

  Bool_t   fFillTaggedDecayHistograms;                
  Int_t    fNDecayBits ;                              
  UInt_t   fDecayBits[AliNeutralMesonSelection::fgkMaxNDecayBits] ; 
  Float_t  fDecayTagsM02Cut ;                         
  
  Bool_t   fFillNLMHistograms;                        
  Bool_t   fLeadingOnly;                              
  Bool_t   fCheckLeadingWithNeutralClusters;          
  Bool_t   fSelectPrimariesInCone;                    
  Bool_t   fMakePrimaryPi0DecayStudy;                 
  
  Bool_t   fFillBackgroundBinHistograms;              
  Int_t    fNBkgBin;                                  
  Float_t  fBkgBinLimit[20];                          

  Bool_t   fFillPtTrigBinHistograms;                  
  Int_t    fNPtTrigBin;                               
  Float_t  fPtTrigBinLimit[20];                       
  
  Float_t  fMinCellsAngleOverlap;                     
  
  //  Analysis data members for multiple cones and pt thresholds
  Int_t    fNCones ;                                  
  Int_t    fNPtThresFrac ;                            
  
  Float_t  fConeSizes[5] ;                            
  Float_t  fPtThresholds[5] ;                         
  Float_t  fPtFractions[5] ;                          
  Float_t  fSumPtThresholds[5] ;                      
  
  TLorentzVector fMomentum;                           
  TLorentzVector fMomIso;                             
  TLorentzVector fMomDaugh1;                          
  TLorentzVector fMomDaugh2;                          
  TVector3       fTrackVector;                        
  TVector3       fProdVertex;                         
 
  AliVCluster*   fCluster;                            
  TObjArray  *   fClustersArr;                        

  //Histograms  
  
  TH1F *   fhEIso ;                                    
  TH1F *   fhPtIso ;                                   
  TH2F *   fhPtCentralityIso ;                         
  TH2F *   fhPtEventPlaneIso ;                         
  TH2F *   fhPtNLocMaxIso ;                            
  TH2F *   fhPhiIso ;                                  
  TH2F *   fhEtaIso ;                                  
  TH2F *   fhEtaPhiIso ;                               
  TH2F *   fhEtaPhiNoIso ;                             
  TH1F *   fhENoIso ;                                  
  TH1F *   fhPtNoIso ;                                 
  TH2F *   fhPtNLocMaxNoIso ;                          
  TH1F *   fhPtDecay       [2][AliNeutralMesonSelection::fgkMaxNDecayBits]; 
  TH2F *   fhEtaPhiDecay   [2][AliNeutralMesonSelection::fgkMaxNDecayBits]; 
  TH2F *   fhPtLambda0Decay[2][AliNeutralMesonSelection::fgkMaxNDecayBits]; 

  TH2F *   fhPtInCone ;                                
  TH2F *   fhPtClusterInCone ;                         
  TH2F *   fhPtCellInCone ;                            
  TH2F *   fhPtTrackInCone ;                           
  TH2F *   fhPtTrackInConeOtherBC ;                    
  TH2F *   fhPtTrackInConeOtherBCPileUpSPD ;           
  TH2F *   fhPtTrackInConeBC0 ;                        
  TH2F *   fhPtTrackInConeVtxBC0 ;                     
  TH2F *   fhPtTrackInConeBC0PileUpSPD ;               
  TH2F *   fhPtInConePileUp[7] ;                       
  TH2F *   fhPtInConeCent ;                            
  TH2F *   fhPerpConeSumPt ;                           
  TH2F *   fhPtInPerpCone ;                            
  
  TH2F *   fhEtaPhiInConeCluster ;                     
  TH2F *   fhEtaPhiCluster ;                           
  TH2F *   fhEtaPhiInConeTrack ;                       
  TH2F *   fhEtaPhiTrack ;                             
  
  TH2F *   fhEtaBandCluster ;                          
  TH2F *   fhPhiBandCluster ;                          
  TH2F *   fhEtaBandTrack   ;                          
  TH2F *   fhPhiBandTrack   ;                          
  TH2F *   fhEtaBandCell ;                             
  TH2F *   fhPhiBandCell ;                             

  TH2F *   fhConePtLead ;                              
  TH2F *   fhConePtLeadCluster ;                       
  TH2F *   fhConePtLeadTrack ;                         
  TH2F *   fhConePtLeadClustervsTrack;                 
  TH2F *   fhConePtLeadClusterTrackFrac;               
  
  TH2F *   fhConeSumPt ;                               
  TH2F *   fhConeSumPtCellTrack ;                      
  TH2F *   fhConeSumPtCell ;                           
  TH2F *   fhConeSumPtCluster ;                        
  TH2F *   fhConeSumPtTrack ;                          
  TH2F *   fhConeSumPtEtaBandUECluster;                
  TH2F *   fhConeSumPtPhiBandUECluster;                
  TH2F *   fhConeSumPtEtaBandUETrack;                  
  TH2F *   fhConeSumPtPhiBandUETrack;                  
  TH2F *   fhConeSumPtEtaBandUECell;                   
  TH2F *   fhConeSumPtPhiBandUECell;                   

  TH2F *   fhConeSumPtTrigEtaPhi ;                     
  TH2F *   fhConeSumPtCellTrackTrigEtaPhi ;            
  TH2F *   fhConeSumPtEtaBandUEClusterTrigEtaPhi;      
  TH2F *   fhConeSumPtPhiBandUEClusterTrigEtaPhi;      
  TH2F *   fhConeSumPtEtaBandUETrackTrigEtaPhi;        
  TH2F *   fhConeSumPtPhiBandUETrackTrigEtaPhi;        
  TH2F *   fhConeSumPtEtaBandUECellTrigEtaPhi;         
  TH2F *   fhConeSumPtPhiBandUECellTrigEtaPhi;         
  
  TH2F *   fhConeSumPtEtaUESub;                        
  TH2F *   fhConeSumPtPhiUESub;                        
  TH2F *   fhConeSumPtEtaUESubTrigEtaPhi;              
  TH2F *   fhConeSumPtPhiUESubTrigEtaPhi;              
  
  TH2F *   fhConeSumPtEtaUESubTrackCell;               
  TH2F *   fhConeSumPtPhiUESubTrackCell;               
  TH2F *   fhConeSumPtEtaUESubTrackCellTrigEtaPhi;     
  TH2F *   fhConeSumPtPhiUESubTrackCellTrigEtaPhi;     
  
  TH2F *   fhConeSumPtEtaUESubCluster;                 
  TH2F *   fhConeSumPtPhiUESubCluster;                 
  TH2F *   fhConeSumPtEtaUESubClusterTrigEtaPhi;       
  TH2F *   fhConeSumPtPhiUESubClusterTrigEtaPhi;       

  TH2F *   fhConeSumPtEtaUESubCell;                    
  TH2F *   fhConeSumPtPhiUESubCell;                    
  TH2F *   fhConeSumPtEtaUESubCellTrigEtaPhi;          
  TH2F *   fhConeSumPtPhiUESubCellTrigEtaPhi;          
  
  TH2F *   fhConeSumPtEtaUESubTrack;                   
  TH2F *   fhConeSumPtPhiUESubTrack;                   
  TH2F *   fhConeSumPtEtaUESubTrackTrigEtaPhi;         
  TH2F *   fhConeSumPtPhiUESubTrackTrigEtaPhi;         
  
  TH2F *   fhFractionTrackOutConeEta;                  
  TH2F *   fhFractionTrackOutConeEtaTrigEtaPhi;        
  TH2F *   fhFractionClusterOutConeEta;                
  TH2F *   fhFractionClusterOutConeEtaTrigEtaPhi;      
  TH2F *   fhFractionClusterOutConePhi;                
  TH2F *   fhFractionClusterOutConePhiTrigEtaPhi;      
  
  TH2F *   fhFractionCellOutConeEta;                   
  TH2F *   fhFractionCellOutConeEtaTrigEtaPhi;         
  TH2F *   fhFractionCellOutConePhi;                   
  TH2F *   fhFractionCellOutConePhiTrigEtaPhi;         
  
  TH2F *   fhConeSumPtClustervsTrack ;                 
  TH2F *   fhConeSumPtClusterTrackFrac ;               
  TH2F *   fhConeSumPtEtaUESubClustervsTrack ;         
  TH2F *   fhConeSumPtPhiUESubClustervsTrack ;         
  TH2F *   fhConeSumPtCellvsTrack;                     
  TH2F *   fhConeSumPtEtaUESubCellvsTrack ;            
  TH2F *   fhConeSumPtPhiUESubCellvsTrack ;            

  TH2F *   fhEtaBandClustervsTrack ;                   
  TH2F *   fhPhiBandClustervsTrack ;                   
  TH2F *   fhEtaBandNormClustervsTrack ;               
  TH2F *   fhPhiBandNormClustervsTrack ;               
  TH2F *   fhEtaBandCellvsTrack ;                      
  TH2F *   fhPhiBandCellvsTrack ;                      
  TH2F *   fhEtaBandNormCellvsTrack ;                  
  TH2F *   fhPhiBandNormCellvsTrack ;                  

  TH2F *   fhConeSumPtSubvsConeSumPtTotPhiTrack;       
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotPhiTrack;   
  TH2F *   fhConeSumPtSubvsConeSumPtTotEtaTrack;       
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotEtaTrack;   
  TH2F *   fhConeSumPtSubvsConeSumPtTotPhiCluster;     
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotPhiCluster; 
  TH2F *   fhConeSumPtSubvsConeSumPtTotEtaCluster;     
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotEtaCluster; 
  TH2F *   fhConeSumPtSubvsConeSumPtTotPhiCell;        
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotPhiCell;    
  TH2F *   fhConeSumPtSubvsConeSumPtTotEtaCell;        
  TH2F *   fhConeSumPtSubNormvsConeSumPtTotEtaCell;    
  TH2F *   fhConeSumPtVSUETracksEtaBand;               
  TH2F *   fhConeSumPtVSUETracksPhiBand;               
  TH2F *   fhConeSumPtVSUEClusterEtaBand;              
  TH2F *   fhConeSumPtVSUEClusterPhiBand;              
  
  // MC
  
  TH2F *   fhEtaPrimMC  [fgkNmcPrimTypes];             
  TH2F *   fhPhiPrimMC  [fgkNmcPrimTypes];             
  TH1F *   fhEPrimMC    [fgkNmcPrimTypes];             
  TH1F *   fhPtPrimMC   [fgkNmcPrimTypes];             
  TH1F *   fhPtPrimMCiso[fgkNmcPrimTypes];             
  
  TH1F *   fhPtPrimMCPi0DecayPairOutOfCone;            
  TH1F *   fhPtPrimMCPi0DecayPairOutOfAcceptance;      
  TH1F *   fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap;   
  TH1F *   fhPtPrimMCPi0DecayPairAcceptInConeLowPt;    
  TH1F *   fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap; 
  TH1F *   fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE; 
  TH1F *   fhPtPrimMCPi0DecayPairNoOverlap;            

  TH1F *   fhPtPrimMCPi0DecayIsoPairOutOfCone;         
  TH1F *   fhPtPrimMCPi0DecayIsoPairOutOfAcceptance;   
  TH1F *   fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap; 
  TH1F *   fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt; 
  TH1F *   fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap;      
  TH1F *   fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE; 
  TH1F *   fhPtPrimMCPi0DecayIsoPairNoOverlap;         

  TH1F *   fhPtPrimMCPi0Overlap;                       
  TH1F *   fhPtPrimMCPi0IsoOverlap;                    

  
  TH1F *   fhPtPrimMCEtaDecayPairOutOfCone;            
  TH1F *   fhPtPrimMCEtaDecayPairOutOfAcceptance;      
  TH1F *   fhPtPrimMCEtaDecayPairOutOfAcceptanceNoOverlap;   
  TH1F *   fhPtPrimMCEtaDecayPairAcceptInConeLowPt;    
  TH1F *   fhPtPrimMCEtaDecayPairAcceptInConeLowPtNoOverlap; 
  TH1F *   fhPtPrimMCEtaDecayPairAcceptInConeLowPtNoOverlapCaloE; 
  TH1F *   fhPtPrimMCEtaDecayPairNoOverlap;            
  
  TH1F *   fhPtPrimMCEtaDecayIsoPairOutOfCone;         
  TH1F *   fhPtPrimMCEtaDecayIsoPairOutOfAcceptance;   
  TH1F *   fhPtPrimMCEtaDecayIsoPairOutOfAcceptanceNoOverlap; 
  TH1F *   fhPtPrimMCEtaDecayIsoPairAcceptInConeLowPt; 
  TH1F *   fhPtPrimMCEtaDecayIsoPairAcceptInConeLowPtNoOverlap; 
  TH1F *   fhPtPrimMCEtaDecayIsoPairAcceptInConeLowPtNoOverlapCaloE; 
  TH1F *   fhPtPrimMCEtaDecayIsoPairNoOverlap;         
  
  TH1F *   fhPtPrimMCEtaOverlap;                       
  TH1F *   fhPtPrimMCEtaIsoOverlap;                    

  
  
  TH1F *   fhPtNoIsoMC  [fgkNmcTypes];                 
  TH1F *   fhPtIsoMC    [fgkNmcTypes];                 
  TH2F *   fhPhiIsoMC   [fgkNmcTypes];                 
  TH2F *   fhEtaIsoMC   [fgkNmcTypes];                 
  
  TH1F *   fhPtDecayMC  [2][AliNeutralMesonSelection::fgkMaxNDecayBits][fgkNmcTypes] ; 
  
  TH2F *   fhPtLambda0MC    [fgkNmcTypes][2];           
  TH2F *   fhPtLambda0MCConv[fgkNmcTypes][2];           

  TH2F *   fhPtLambda0MCWith1Overlap    [fgkNmcTypes][2];           
  TH2F *   fhPtLambda0MCConvWith1Overlap[fgkNmcTypes][2];           

  TH2F *   fhPtLambda0MCWithNOverlap    [fgkNmcTypes][2];           
  TH2F *   fhPtLambda0MCConvWithNOverlap[fgkNmcTypes][2];           
  
  TH2F *   fhPtNOverlap    [fgkNmcTypes][2];                        
  TH2F *   fhPtNOverlapConv[fgkNmcTypes][2];                        
  
  // Multiple cut analysis
  TH2F *   fhSumPtLeadingPt[5] ;                       
  TH2F *   fhPtLeadingPt[5] ;                          
  TH2F *   fhPerpSumPtLeadingPt[5] ;                   
  TH2F *   fhPerpPtLeadingPt[5];                       

  TH1F *   fhPtThresIsolated[5][5] ;                   
  TH1F *   fhPtFracIsolated[5][5] ;                    
  TH1F *   fhSumPtIsolated[5][5] ;                     
  
  TH2F *   fhEtaPhiPtThresIso[5][5] ;                  
  TH2F *   fhEtaPhiPtThresDecayIso[5][5] ;             
  TH1F *   fhPtPtThresDecayIso[5][5] ;                 
  
  TH2F *   fhEtaPhiPtFracIso[5][5] ;                   
  TH2F *   fhEtaPhiPtFracDecayIso[5][5] ;              
  TH1F *   fhPtPtFracDecayIso[5][5] ;                  

  TH2F *   fhEtaPhiPtSumIso[5][5] ;                    
  TH2F *   fhEtaPhiPtSumDecayIso[5][5] ;               
  TH1F *   fhPtPtSumDecayIso[5][5] ;                   
  
  TH2F *   fhEtaPhiSumDensityIso[5][5];                
  TH2F *   fhEtaPhiSumDensityDecayIso[5][5];           
  TH1F *   fhPtSumDensityIso[5][5];                    
  TH1F *   fhPtSumDensityDecayIso[5][5];               
  
  TH1F *   fhPtFracPtSumIso[5][5] ;                    
  TH1F *   fhPtFracPtSumDecayIso[5][5] ;               
  TH2F *   fhEtaPhiFracPtSumIso[5][5];                 
  TH2F *   fhEtaPhiFracPtSumDecayIso[5][5];            
 
  // Multiple cut MC
  TH1F *   fhPtThresIsolatedMC[fgkNmcTypes][5][5];     
  TH1F *   fhPtFracIsolatedMC [fgkNmcTypes][5][5];     
  TH1F *   fhSumPtIsolatedMC  [fgkNmcTypes][5][5];     
  TH2F *   fhSumPtLeadingPtMC [fgkNmcTypes][5];        

  // Track matching studies
  TH2F *   fhTrackMatchedDEta[2]     ;                 
  TH2F *   fhTrackMatchedDPhi[2]     ;                 
  TH2F *   fhTrackMatchedDEtaDPhi[2] ;                 
  TH2F *   fhTrackMatchedDEtaMC[fgkNmcTypes][2]     ;  
  TH2F *   fhTrackMatchedDPhiMC[fgkNmcTypes][2]     ;  
  TH2F *   fhTrackMatchedDEtaDPhiMC[fgkNmcTypes][2] ;  
  TH2F *   fhdEdx[2]  ;                                
  TH2F *   fhEOverP[2];                                
  TH2F *   fhTrackMatchedMCParticle[2];                

  // Shower Shape histograms
  TH2F *   fhELambda0[2];                              
  TH2F *   fhPtLambda0[2];                             
//TH2F *   fhELambda1[2];                              //!<! Shower shape of (non) isolated photons (do not apply SS cut previously).
  TH2F *   fhELambda0TRD[2];                           
  TH2F *   fhPtLambda0TRD[2];                          
//TH2F *   fhELambda1TRD[2];                           //!<! Shower shape of (non) isolated photons, SM behind TRD (do not apply SS cut previously).

  TH1F **  fhPtLeadConeBin ;                           
    
  TH1F **  fhSumPtConeBin  ;                           
    
  TH1F **  fhPtLeadConeBinMC ;                         
    
  TH1F **  fhSumPtConeBinMC  ;                         

  TH1F **  fhPtLeadConeBinDecay ;                      
    
  TH1F **  fhSumPtConeBinDecay  ;                      
  
  TH2F **  fhPtLeadConeBinLambda0 ;                    
    
  TH2F **  fhSumPtConeBinLambda0  ;                    
    
  TH2F **  fhPtLeadConeBinLambda0MC ;                  
    
  TH2F **  fhSumPtConeBinLambda0MC  ;                  

  TH1F **  fhPtTrigBinPtLeadCone ;                     
    
  TH1F **  fhPtTrigBinSumPtCone  ;                     

  TH1F **  fhPtTrigBinPtLeadConeMC ;                   
    
  TH1F **  fhPtTrigBinSumPtConeMC  ;                   
  
  TH1F **  fhPtTrigBinPtLeadConeDecay ;                
  
  TH1F **  fhPtTrigBinSumPtConeDecay  ;                

  TH2F **  fhPtTrigBinLambda0vsPtLeadCone ;            
    
  TH2F **  fhPtTrigBinLambda0vsSumPtCone  ;            
    
  TH2F **  fhPtTrigBinLambda0vsPtLeadConeMC ;          
    
  TH2F **  fhPtTrigBinLambda0vsSumPtConeMC  ;          

  // Local maxima
  TH2F *   fhNLocMax[2];                               
  TH2F *   fhELambda0LocMax1[2] ;                      
  TH2F *   fhELambda1LocMax1[2] ;                      
  TH2F *   fhELambda0LocMax2[2] ;                      
  TH2F *   fhELambda1LocMax2[2] ;                      
  TH2F *   fhELambda0LocMaxN[2] ;                      
  TH2F *   fhELambda1LocMaxN[2] ;                      
  
  // Pile-up
  TH1F *   fhEIsoPileUp[7] ;                           
  TH1F *   fhPtIsoPileUp[7] ;                          
  TH1F *   fhENoIsoPileUp[7] ;                         
  TH1F *   fhPtNoIsoPileUp[7] ;                        
  TH2F *   fhTimeENoCut;                               
  TH2F *   fhTimeESPD;                                 
  TH2F *   fhTimeESPDMulti;                            
  TH2F *   fhTimeNPileUpVertSPD;                       
  TH2F *   fhTimeNPileUpVertTrack;                     
  TH2F *   fhTimeNPileUpVertContributors;              
  TH2F *   fhTimePileUpMainVertexZDistance;            
  TH2F *   fhTimePileUpMainVertexZDiamond;             
  
  TH2F *   fhMCConversionVertex[2];                    
  TH2F *   fhMCConversionVertexTRD[2];                 
  TH2F *   fhMCConversionLambda0Rcut[6][2];            
  TH2F *   fhMCConversionLambda0RcutTRD[6][2];         
  
//TH2F *   fhLam0EMCALRegion   [2][4][3];                //!<! Cluster lambda0 vs  E, in different EMCal regions
//TH2F *   fhLam0EMCALRegionTRD[2][4][3];                //!<! Cluster lambda0 vs  E, in different EMCal regions, SM covered by TRD
//TH2F *   fhLam0EMCALRegionMCConvRcut   [2][4][3][6];   //!<! Cluster lambda0 vs  E, in different EMCal regions, MC photon conversions, depending on conversion vertex
//TH2F *   fhLam0EMCALRegionTRDMCConvRcut[2][4][3][6];   //!<! Cluster lambda0 vs  E, in different EMCal regions, SM covered by TRD,  MC photon conversions, depending on conversion vertex

  TH2F *   fhLam0EMCALRegionPerSM[2][4][3][20];          
  TH2F *   fhEtaPhiLam0BinPtBin[2][7];                   

  
  AliAnaParticleIsolation(              const AliAnaParticleIsolation & iso) ;
    
  AliAnaParticleIsolation & operator = (const AliAnaParticleIsolation & iso) ;
  
  ClassDef(AliAnaParticleIsolation,37) ;

} ;


#endif //ALIANAPARTICLEISOLATION_H