AliAnaParticleHadronCorrelation.h

Go to the documentation of this file.

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

//_________________________________________________________________________
//_________________________________________________________________________

#include "AliAnaCaloTrackCorrBaseClass.h"
class AliCaloTrackParticleCorrelation ;

class AliAnaParticleHadronCorrelation : public AliAnaCaloTrackCorrBaseClass {
  
public:
  
  AliAnaParticleHadronCorrelation() ;
  
  virtual ~AliAnaParticleHadronCorrelation() ;
  
  // General methods
  
  TObjString * GetAnalysisCuts();
  
  TList      * GetCreateOutputObjects();
  
  void         Init();
  
  void         InitParameters();
  
  void         FillEventMixPool() ;
  
  void         MakeAnalysisFillHistograms() ;
  
  void         Print(const Option_t * opt) const;
  
  // Main analysis methods
  
  Bool_t       FindLeadingOppositeHadronInWindow(AliCaloTrackParticleCorrelation * particle);
  
  Bool_t       GetDecayPhotonMomentum   (Int_t indexPhoton1, Int_t indexPhoton2, Int_t idetector);
  
  void         MakeChargedCorrelation   (AliCaloTrackParticleCorrelation * particle) ;
  
  void         MakeNeutralCorrelation   (AliCaloTrackParticleCorrelation * particle) ;
  
  void         MakeMCChargedCorrelation (Int_t triggerMCLable, Int_t histoIndex, Bool_t lostDecayPair) ;
  
  void         MakeChargedMixCorrelation(AliCaloTrackParticleCorrelation * particle) ;
  
  // Filling histogram methods
  
  void         FillChargedAngularCorrelationHistograms  (Float_t ptAssoc,  Float_t ptTrig,      Int_t   assocBin,
                                                         Float_t phiAssoc, Float_t phiTrig,     Float_t deltaPhi,
                                                         Float_t etaAssoc, Float_t etaTrig,     Int_t   sm,
                                                         Int_t   decayTag, Float_t hmpidSignal, Int_t   outTOF,
                                                         Int_t   cenbin,   Int_t   mcTag);
  
  void         FillChargedEventMixPool();
  
  Bool_t       FillChargedMCCorrelationHistograms       (Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
                                                         Float_t mcTrigPt,  Float_t mcTrigPhi,  Float_t mcTrigEta,
                                                         Int_t histoIndex,  Bool_t  lostDecayPair);
  
  void         FillChargedMomentumImbalanceHistograms   (Float_t ptTrig,   Float_t ptAssoc,
                                                         Float_t deltaPhi, Int_t sm,
                                                         Int_t   cenbin,   Int_t charge,
                                                         Int_t   assocBin, Int_t decayTag,
                                                         Int_t   outTOF,   Int_t mcTag );
  
  void         FillChargedUnderlyingEventHistograms     (Float_t ptTrig,   Float_t ptAssoc, Float_t deltaPhi, 
                                                         Int_t sm, Int_t cenbin, Int_t outTOF, Int_t   mcTag);
  
  void         FillChargedUnderlyingEventSidesHistograms(Float_t ptTrig,   Float_t ptAssoc,
                                                         Float_t deltaPhi, Int_t   mcTag);
  
  void         FillDecayPhotonCorrelationHistograms     (Float_t ptAssoc,  Float_t phiAssoc, Bool_t bChargedOrNeutral);
  
  void         FillNeutralEventMixPool();
  
  
  void         FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig,   Float_t ptAssoc,
                                                         Float_t zT,       Float_t hbpZT,
                                                         Float_t deltaPhi);
  
  void         InvMassHisto(AliCaloTrackParticleCorrelation * trigger, Int_t mcIndex);
  
  Int_t        GetMCTagHistogramIndex(Int_t tag);
  
  enum mcTypes     { kmcPhoton     = 0, kmcPi0      = 1, kmcPi0Decay = 2, kmcEta              = 3, kmcEtaDecay         = 4,
    kmcOtherDecay = 5, kmcElectron = 6, kmcHadron   = 7, kmcPi0DecayLostPair = 8, kmcEtaDecayLostPair = 9} ;
  
  static const Int_t fgkNmcTypes = 10;    
  
  
  Bool_t       IsTriggerTheEventLeadingParticle();
  
  // Parameter setter and getter
  
  Float_t      GetMinimumTriggerPt()       const { return GetMinPt()             ; }
  Float_t      GetMaximumTriggerPt()       const { return GetMaxPt()             ; }
  void         SetTriggerPtRange(Float_t min, Float_t max)
  { SetMinPt(min), SetMaxPt(max)                                    ; }
  
  
  Float_t      GetMaximumAssociatedPt()    const { return fMaxAssocPt            ; }
  Float_t      GetMinimumAssociatedPt()    const { return fMinAssocPt            ; }
  void         SetAssociatedPtRange(Float_t min, Float_t max)
  { fMaxAssocPt   = max ;           fMinAssocPt  = min              ; }
  
  Double_t     GetDeltaPhiMaxCut()         const { return fDeltaPhiMaxCut        ; }
  Double_t     GetDeltaPhiMinCut()         const { return fDeltaPhiMinCut        ; }
  void         SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
  { fDeltaPhiMaxCut   = phimax ;    fDeltaPhiMinCut   = phimin      ; }
  
  // Leading Hadron
  Double_t     GetLeadHadronPhiMaxCut()    const { return fMaxLeadHadPhi         ; }
  Double_t     GetLeadHadronPhiMinCut()    const { return fMinLeadHadPhi         ; }
  void         SetLeadHadronPhiCut(Float_t min, Float_t max)
  { fMaxLeadHadPhi = max ;          fMinLeadHadPhi  = min           ; }
  
  Double_t     GetLeadHadronPtMinCut()     const { return fMinLeadHadPt          ; }
  Double_t     GetLeadHadronPtMaxCut()     const { return fMaxLeadHadPt          ; }
  void         SetLeadHadronPtCut(Float_t min, Float_t max)
  { fMaxLeadHadPt  = max ;           fMinLeadHadPt  = min           ; }
  
  Bool_t       IsLeadHadronCutOn()        const { return fSelectLeadingHadronAngle   ; }
  void         SwitchOnLeadHadronSelection()    { fSelectLeadingHadronAngle = kTRUE  ; }
  void         SwitchOffLeadHadronSelection()   { fSelectLeadingHadronAngle = kFALSE ; }
  
  void         SwitchOnFillLeadHadronHistograms() { fFillLeadHadOppositeHisto = kTRUE  ; }
  void         SwitchOffFillLeadHadronHistograms(){ fFillLeadHadOppositeHisto = kFALSE ; }
  
  void         SwitchOnInvariantMassHistograms() { fFillInvMassHisto = kTRUE      ; }
  void         SwitchOffInvariantMassHistograms(){ fFillInvMassHisto = kFALSE     ; }
  
  void         SwitchOnBackgroundBinsPtInConeHistograms() { fFillBkgBinsHisto = kTRUE  ; }
  void         SwitchOffBackgroundBinsPtInConeHistograms(){ fFillBkgBinsHisto = kFALSE ; }
  
  void         SwitchOnBackgroundBinsTaggedDecayPtInConeHistograms() { fFillTaggedDecayHistograms = kTRUE  ; }
  void         SwitchOffBackgroundBinsTaggedDecayPtInConeHistograms(){ fFillTaggedDecayHistograms = kFALSE ; }
  
  // Background bins
  void         SetNBackgroundBins(Int_t n)           { if(n < 19) fNBkgBin = n ; }
  void         SetBackgroundLimits(Int_t i,Float_t l){ if(i <= fNBkgBin) fBkgBinLimit[i] = l; }
  
  // UE
  
  Double_t     GetUeDeltaPhiMaxCut()       const { return fUeDeltaPhiMaxCut      ; }
  Double_t     GetUeDeltaPhiMinCut()       const { return fUeDeltaPhiMinCut      ; }
  
  void         SetUeDeltaPhiCutRange(Double_t uephimin, Double_t uephimax)
  { fUeDeltaPhiMaxCut = uephimax ;  fUeDeltaPhiMinCut = uephimin ; }
  
  Bool_t       IsSeveralUEOn()             const { return fMakeSeveralUE         ; }
  void         SwitchOnSeveralUECalculation()    { fMakeSeveralUE      = kTRUE   ; }
  void         SwitchOffSeveralUECalculation()   { fMakeSeveralUE      = kFALSE  ; }
  
  // Do trigger-neutral correlation
  Bool_t       DoNeutralCorr()             const { return fNeutralCorr           ; }
  void         SwitchOnNeutralCorr()             { fNeutralCorr      = kTRUE     ; }
  void         SwitchOffNeutralCorr()            { fNeutralCorr      = kFALSE    ; }
  
  // Taking the absolute leading as the trigger or not
  Bool_t       DoAbsoluteLeading()         const { return fMakeAbsoluteLeading   ; }
  void         SwitchOnAbsoluteLeading()         { fMakeAbsoluteLeading = kTRUE  ; }
  void         SwitchOffAbsoluteLeading()        { fMakeAbsoluteLeading = kFALSE ; }
  
  // Taking the near side leading as the trigger or not
  Bool_t       DoNearSideLeading()         const { return fMakeNearSideLeading   ; }
  void         SwitchOnNearSideLeading()         { fMakeNearSideLeading = kTRUE  ; }
  void         SwitchOffNearSideLeading()        { fMakeNearSideLeading = kFALSE ; }
  
  // Do decay-hadron correlation if it is pi0 trigger
  Bool_t       IsPi0Trigger()              const { return fPi0Trigger            ; }
  void         SwitchOnPi0TriggerDecayCorr()     { fPi0Trigger          = kTRUE  ; }
  void         SwitchOffPi0TriggerDecayCorr()    { fPi0Trigger          = kFALSE ; }
  
  Bool_t       IsDecayTrigger()            const { return fDecayTrigger          ; }
  void         SwitchOnDecayTriggerDecayCorr()   { fDecayTrigger        = kTRUE  ; }
  void         SwitchOffDecayTriggerDecayCorr()  { fDecayTrigger        = kFALSE ; }
  void         SetNDecayBits(Int_t n)            { fNDecayBits = n               ; }
  void         SetDecayBits(Int_t i, UInt_t bit)
  { if(i < AliNeutralMesonSelection::fgkMaxNDecayBits) fDecayBits[i] = bit     ; }
  
  Bool_t       IsHMPIDCorrelation()        const { return fHMPIDCorrelation      ; }
  void         SwitchOnHMPIDCorrelation()        { fHMPIDCorrelation    = kTRUE  ; }
  void         SwitchOffHMPIDCorrelation()       { fHMPIDCorrelation    = kFALSE ; }
  
  void         SwitchOnFillBradHistograms()      { fFillBradHisto       = kTRUE  ; }
  void         SwitchOffFillBradHistograms()     { fFillBradHisto       = kFALSE ; }
 
  void         SwitchOnFillDeltaEtaPhiPtTrigHistograms()  { fFillDeltaPhiDeltaEtaAssocPt = kTRUE  ; }
  void         SwitchOffFillDeltaEtaPhiPtTrigHistograms() { fFillDeltaPhiDeltaEtaAssocPt = kFALSE ; }
  
  Bool_t       OnlyIsolated()              const { return fSelectIsolated        ; }
  void         SelectIsolated(Bool_t s)          { fSelectIsolated   = s         ; }
  
  void         SetPi0AODBranchName(TString n)    { fPi0AODBranchName = n         ; }
  
  void         SetAODNamepTInConeHisto(TString m){ fAODNamepTInConeHisto = m         ; }
  
  void         SetNAssocPtBins(Int_t n) ;
  void         SetAssocPtBinLimit(Int_t ibin, Float_t pt) ;
  
  void         SetNTriggerPtBins(Int_t n) ;
  void         SetTriggerPtBinLimit(Int_t ibin, Float_t pt) ;
  
  Bool_t       IsMixStoredInReaderOn()     const { return fUseMixStoredInReader  ; }
  void         SwitchOnUseMixStoredInReader()    { fUseMixStoredInReader = kTRUE ; }
  void         SwitchOffUseMixStoredInReader()   { fUseMixStoredInReader = kFALSE; }
  
  void         SwitchOnFillNeutralInMixedEvent() { fFillNeutralEventMixPool = kTRUE  ; }
  void         SwitchOffFillNeutralInMixedEvent(){ fFillNeutralEventMixPool = kFALSE ; }
  
  void         SetM02Cut(Float_t min=0, Float_t max=10)  { fM02MinCut   = min ; fM02MaxCut  = max ; }
  
  void         SwitchOnCorrelationVzBin()        { fCorrelVzBin          = kTRUE  ; }
  void         SwitchOffCorrelationVzBin()       { fCorrelVzBin          = kFALSE ; }
  
  void         SwitchOnFillTriggerAODWithReferences()   { fFillAODWithReferences = kTRUE  ; }
  void         SwitchOffFillTriggerAODWithReferences()  { fFillAODWithReferences = kFALSE ; }
  
  void         SwitchOnCheckNeutralClustersForLeading() { fCheckLeadingWithNeutralClusters = kTRUE  ; }
  void         SwitchOffCheckNeutralClustersForLeading(){ fCheckLeadingWithNeutralClusters = kFALSE ; }
  
  void         SwitchOnFillEtaGapHistograms()    { fFillEtaGapsHisto    = kTRUE  ; }
  void         SwitchOffFillEtaGapHistograms()   { fFillEtaGapsHisto    = kFALSE ; }
  
  void         SwitchOnFillPtImbalancePerPtABinHistograms()  { fFillMomImbalancePtAssocBinsHisto = kTRUE  ; }
  void         SwitchOffFillPtImbalancePerPtABinHistograms() { fFillMomImbalancePtAssocBinsHisto = kFALSE ; }
  
  void         SwitchOnFillHistogramsPerSM()     { fFillPerSMHistograms = kTRUE  ; }
  void         SwitchOffFillHistogramsPerSM()    { fFillPerSMHistograms = kFALSE ; }  

  void         SwitchOnFillHistogramsPerTCardIndex()  { fFillPerTCardIndexHistograms = kTRUE  ; }
  void         SwitchOffFillHistogramsPerTCardIndex() { fFillPerTCardIndexHistograms = kFALSE ; }  
  
  void         SetMCGenType(Int_t min = 0, Int_t max = 6) { if(min >= 0 && min < fgkNmcTypes) fMCGenTypeMin = min ;
    if(max >= 0 && max < fgkNmcTypes) fMCGenTypeMax = max ; }
  
private:
  
  Bool_t       fFillAODWithReferences;                   
  
  Bool_t       fCheckLeadingWithNeutralClusters;         
  
  Float_t      fMaxAssocPt ;                             
  Float_t      fMinAssocPt ;                             
  
  Double_t     fDeltaPhiMaxCut ;                         
  Double_t     fDeltaPhiMinCut ;                         
  
  Bool_t       fSelectIsolated ;                         
  
  Bool_t       fMakeSeveralUE ;                          
  
  Double_t     fUeDeltaPhiMaxCut ;                       
  Double_t     fUeDeltaPhiMinCut ;                       
  
  TString      fPi0AODBranchName;                        
  
  TString      fAODNamepTInConeHisto;                    
  
  Bool_t       fNeutralCorr ;                            
  
  Bool_t       fPi0Trigger ;                             
  
  Bool_t       fDecayTrigger ;                           
  
  Int_t        fNDecayBits ;                             
  
  UInt_t       fDecayBits[AliNeutralMesonSelection::fgkMaxNDecayBits] ;
  
  Int_t        fNBkgBin;                                 
  Float_t      fBkgBinLimit[20];                         
  
  //

  Bool_t       fMakeAbsoluteLeading ;                    
  Bool_t       fMakeNearSideLeading ;                    
  
  Int_t        fLeadingTriggerIndex ;                    
  
  Bool_t       fHMPIDCorrelation    ;                    
  
  Bool_t       fFillBradHisto ;                          
  Bool_t       fFillDeltaPhiDeltaEtaAssocPt;             
  Int_t        fNAssocPtBins ;                           
  Float_t      fAssocPtBinLimit[20] ;                    
  
  Int_t        fNTrigPtBins ;                            
  Float_t      fTrigPtBinLimit[20] ;                     
  
  Bool_t       fCorrelVzBin ;                            
  
  TList **     fListMixTrackEvents ;                     
  
  TList **     fListMixCaloEvents ;                      
  
  Bool_t       fUseMixStoredInReader;                    
  
  Bool_t       fFillNeutralEventMixPool;                 
  
  Float_t      fM02MaxCut   ;                            
  Float_t      fM02MinCut   ;                            
  
  Bool_t       fSelectLeadingHadronAngle;                
  
  Bool_t       fFillLeadHadOppositeHisto;                
  
  Float_t      fMinLeadHadPhi;                           
  Float_t      fMaxLeadHadPhi;                           
  
  Float_t      fMinLeadHadPt;                            
  Float_t      fMaxLeadHadPt;                            
  
  Bool_t       fFillEtaGapsHisto;                        
  
  Bool_t       fFillMomImbalancePtAssocBinsHisto;        
  
  Bool_t       fFillInvMassHisto;                        
  
  Bool_t       fFillBkgBinsHisto;                        
  
  Bool_t       fFillPerSMHistograms ;                    
  
  Bool_t       fFillPerTCardIndexHistograms ;            
  Int_t        fTCardIndex;                              
  
  Bool_t       fFillTaggedDecayHistograms;               
    
  Float_t      fDecayTagsM02Cut;                         
  
  Int_t        fMCGenTypeMin;                            
  Int_t        fMCGenTypeMax;                            
  
  TVector3       fTrackVector;                           
  TLorentzVector fMomentum;                              
  TLorentzVector fMomentumIM;                            
  TLorentzVector fDecayMom1;                             
  TLorentzVector fDecayMom2;                             
  
  // Histograms
  
  // Trigger particles
  TH1F *       fhPtTriggerInput;                         
  TH1F *       fhPtTriggerSSCut;                         
  TH1F *       fhPtTriggerIsoCut;                        
  TH1F *       fhPtTriggerFidCut;                        
  TH1F *       fhPtTrigger;                              
  TH1F *       fhPtTriggerVtxBC0;                        
  TH1F *       fhPtTriggerPileUp[7];                     
  TH2F *       fhPtTriggerVzBin;                         
  TH2F *       fhPtTriggerBin;                           
  TH2F *       fhPhiTrigger;                             
  TH2F *       fhEtaTrigger;                             
  
  TH1F *       fhPtTriggerMC[fgkNmcTypes];               
  
  TH1F *       fhPtDecayTrigger  [AliNeutralMesonSelection::fgkMaxNDecayBits];              
  TH1F *       fhPtDecayTriggerMC[AliNeutralMesonSelection::fgkMaxNDecayBits][fgkNmcTypes]; 
  
  TH2F *       fhPtTriggerCentrality;                    
  TH2F *       fhPtTriggerEventPlane;                    
  TH2F *       fhTriggerEventPlaneCentrality;            
  
  TH1F *       fhPtTriggerMixed;                         
  TH2F *       fhPtTriggerMixedVzBin;                    
  TH2F *       fhPtTriggerMixedBin;                      
  TH2F *       fhPhiTriggerMixed;                        
  TH2F *       fhEtaTriggerMixed;                        
  
  // Leading hadron in the opposite side of the trigger
  TH2F *       fhPtLeadingOppositeHadron;                
  TH2F *       fhPtDiffPhiLeadingOppositeHadron;         
  TH2F *       fhPtDiffEtaLeadingOppositeHadron;         
  TH1F *       fhPtNoLeadingOppositeHadron;              
  TH2F *       fhEtaPhiNoLeadingOppositeHadron;          
  
  //trigger-charged histograms
  TH2F *       fhDeltaPhiDeltaEtaCharged ;               
  TH2F *       fhPhiCharged  ;                           
  TH2F *       fhEtaCharged  ;                           
  TH2F *       fhDeltaPhiCharged  ;                      
  TH2F *       fhDeltaEtaCharged  ;                      
  TH2F *       fhDeltaPhiChargedPt  ;                    
  TH2F *       fhDeltaPhiUeChargedPt ;                   
  TH1F *       fhUePart;                                 
  TH2F *       fhXECharged  ;                            
  TH2F *       fhXECharged_Cone2  ;                      
  TH2F *       fhXEUeCharged  ;                          
  TH2F *       fhXEUeChargedSmallCone  ;                 
  TH2F *       fhXEUeChargedMediumCone  ;                
  TH2F *       fhXEUeChargedLargeCone  ;                 
  TH2F *       fhXEPosCharged  ;                         
  TH2F *       fhXENegCharged  ;                         
  TH2F *       fhPtHbpXECharged  ;                       
  TH2F *       fhPtHbpXECharged_Cone2  ;                 
  TH2F *       fhPtHbpXEUeCharged  ;                     
  TH2F *       fhZTCharged  ;                            
  TH2F *       fhZTUeCharged  ;                          
  TH2F *       fhZTPosCharged  ;                         
  TH2F *       fhZTNegCharged  ;                         
  TH2F *       fhPtHbpZTCharged  ;                       
  TH2F *       fhPtHbpZTUeCharged  ;                     
  
  TH2F *       fhXEChargedMC[fgkNmcTypes]  ;             
  TH2F *       fhDeltaPhiChargedMC[fgkNmcTypes];         
  
  TH2F *       fhXEUeChargedRightMC[fgkNmcTypes];        
  TH2F *       fhXEUeChargedLeftMC[fgkNmcTypes];         
  
  TH2F *       fhDeltaPhiDeltaEtaChargedPtA3GeV;         
  TH2F *       fhDeltaPhiChargedPtA3GeV  ;               
  TH2F *       fhDeltaEtaChargedPtA3GeV  ;               
  
  // Events tagged as pileup by SDD,EMCal, or combination
  TH2F *       fhDeltaPhiChargedPileUp[7]  ;             
  TH2F *       fhDeltaEtaChargedPileUp[7]  ;             
  TH2F *       fhDeltaPhiChargedPtA3GeVPileUp[7] ;       
  TH2F *       fhDeltaEtaChargedPtA3GeVPileUp[7] ;       
  TH2F *       fhXEChargedPileUp[7]  ;                   
  TH2F *       fhXEUeChargedPileUp[7]  ;                 
  TH2F *       fhZTChargedPileUp[7]  ;                   
  TH2F *       fhZTUeChargedPileUp[7]  ;                 
  TH2F *       fhPtTrigChargedPileUp[7] ;                
  
  TH2F *       fhDeltaPhiChargedOtherBC  ;               
  TH2F *       fhDeltaPhiChargedPtA3GeVOtherBC ;         
  TH2F *       fhXEChargedOtherBC  ;                     
  TH2F *       fhXEUeChargedOtherBC  ;                   
  TH2F *       fhZTChargedOtherBC  ;                     
  TH2F *       fhZTUeChargedOtherBC  ;                   
  TH2F *       fhPtTrigChargedOtherBC ;                  
  
  TH2F *       fhDeltaPhiChargedBC0  ;                   
  TH2F *       fhDeltaPhiChargedPtA3GeVBC0 ;             
  TH2F *       fhXEChargedBC0  ;                         
  TH2F *       fhXEUeChargedBC0  ;                       
  TH2F *       fhZTChargedBC0  ;                         
  TH2F *       fhZTUeChargedBC0  ;                       
  TH2F *       fhPtTrigChargedBC0 ;                      
  
  TH2F *       fhDeltaPhiChargedVtxBC0  ;                
  TH2F *       fhDeltaPhiChargedPtA3GeVVtxBC0 ;          
  TH2F *       fhXEChargedVtxBC0  ;                      
  TH2F *       fhXEUeChargedVtxBC0  ;                    
  TH2F *       fhZTChargedVtxBC0  ;                      
  TH2F *       fhZTUeChargedVtxBC0  ;                    
  TH2F *       fhPtTrigChargedVtxBC0 ;                   
  
  // If several UE calculation is on, most useful for jet-jet events contribution
  TH2F *       fhDeltaPhiUeLeftCharged  ;                
  TH2F *       fhDeltaPhiUeLeftUpCharged;                
  TH2F *       fhDeltaPhiUeRightUpCharged;               
  TH2F *       fhDeltaPhiUeLeftDownCharged;              
  TH2F *       fhDeltaPhiUeRightDownCharged;             
  TH2F *       fhXEUeLeftCharged  ;                      
  TH2F *       fhXEUeLeftUpCharged  ;                    
  TH2F *       fhXEUeRightUpCharged ;                    
  TH2F *       fhXEUeLeftDownCharged  ;                  
  TH2F *       fhXEUeRightDownCharged ;                  
  TH2F *       fhPtHbpXEUeLeftCharged  ;                 
  TH2F *       fhZTUeLeftCharged  ;                      
  TH2F *       fhPtHbpZTUeLeftCharged  ;                 
  
  // For pout and kt extraction
  TH2F *       fhPtTrigPout  ;                           
  TH2F *       fhPtTrigCharged ;                         
  
  TH2F **      fhDeltaPhiChargedMult ;                   
  
  TH2F **      fhDeltaEtaChargedMult ;                   
  
  TH2F **      fhXEMult  ;                               
  
  TH2F **      fhXEUeMult  ;                             
  
  TH2F **      fhZTMult  ;                               
  
  TH2F **      fhZTUeMult  ;                             
  
  TH2F *       fhAssocPtBkg;                             
  
  TH3F **      fhDeltaPhiDeltaEtaAssocPtBin;             
  
  TH2F **      fhDeltaPhiAssocPtBin;                     
  
  TH2F **      fhDeltaPhiAssocPtBinDEta08;               
  
  TH2F **      fhDeltaPhiAssocPtBinDEta0 ;               
  
  TH2F **      fhDeltaPhiAssocPtBinHMPID;                
  
  TH2F **      fhDeltaPhiAssocPtBinHMPIDAcc;             
  
  TH2F **      fhDeltaPhiBradAssocPtBin;                 
  
  TH2F *       fhDeltaPhiBrad;                           
  
  TH2F **      fhXEAssocPtBin ;                          
  
  TH2F **      fhZTAssocPtBin ;                          
  
  TH2F **      fhXEVZ ;                                  
  
  TH2F **      fhZTVZ ;                                  
  
  // Trigger-neutral histograms
  TH2F *       fhDeltaPhiDeltaEtaNeutral ;               
  TH2F *       fhPhiNeutral   ;                          
  TH2F *       fhEtaNeutral   ;                          
  TH2F *       fhDeltaPhiNeutral   ;                     
  TH2F *       fhDeltaEtaNeutral  ;                      
  TH2F *       fhDeltaPhiNeutralPt  ;                    
  TH2F *       fhDeltaPhiUeNeutralPt ;                   
  TH2F *       fhXENeutral  ;                            
  TH2F *       fhXEUeNeutral  ;                          
  TH2F *       fhPtHbpXENeutral  ;                       
  TH2F *       fhPtHbpXEUeNeutral  ;                     
  TH2F *       fhZTNeutral  ;                            
  TH2F *       fhZTUeNeutral  ;                          
  TH2F *       fhPtHbpZTNeutral  ;                       
  TH2F *       fhPtHbpZTUeNeutral  ;                     
  
  // If several UE calculation is on,
  TH2F *       fhDeltaPhiUeLeftNeutral  ;                
  TH2F *       fhXEUeLeftNeutral  ;                      
  TH2F *       fhPtHbpXEUeLeftNeutral  ;                 
  TH2F *       fhZTUeLeftNeutral  ;                      
  TH2F *       fhPtHbpZTUeLeftNeutral  ;                 
  
  // Pi0/Eta trigger correlation, recover input photons
  TH2F *       fhPtPi0DecayRatio ;                       
  TH2F *       fhDeltaPhiPi0DecayCharged  ;              
  TH2F *       fhXEPi0DecayCharged ;                     
  TH2F *       fhZTPi0DecayCharged ;                     
  
  TH2F *       fhDeltaPhiPi0DecayNeutral  ;              
  TH2F *       fhXEPi0DecayNeutral ;                     
  TH2F *       fhZTPi0DecayNeutral ;                     
  
  // Decay photon trigger correlation
  TH2F *       fhDeltaPhiDecayCharged[AliNeutralMesonSelection::fgkMaxNDecayBits]; 
  TH2F *       fhXEDecayCharged[AliNeutralMesonSelection::fgkMaxNDecayBits];       
  TH2F *       fhZTDecayCharged[AliNeutralMesonSelection::fgkMaxNDecayBits];       
  
  TH2F **      fhDeltaPhiDecayChargedAssocPtBin;         
  
  // If the data is MC, correlation with generated particles
  // check the origin of the cluster : decay photon (pi0, eta, other), merged photon (pi0),
  // hadron, rest of photons (prompt, FSR, ISR)
  TH1F *       fhMCPtTrigger[fgkNmcTypes];               
  TH2F *       fhMCPhiTrigger[fgkNmcTypes];              
  TH2F *       fhMCEtaTrigger[fgkNmcTypes];              
  TH1F *       fhMCPtTriggerNotLeading[fgkNmcTypes];     
  TH2F *       fhMCPhiTriggerNotLeading[fgkNmcTypes];    
  TH2F *       fhMCEtaTriggerNotLeading[fgkNmcTypes];    
  TH2F *       fhMCEtaCharged[fgkNmcTypes];              
  TH2F *       fhMCPhiCharged[fgkNmcTypes];              
  TH2F *       fhMCDeltaEtaCharged[fgkNmcTypes];         
  TH2F *       fhMCDeltaPhiCharged[fgkNmcTypes];         
  TH2F *       fhMCDeltaPhiDeltaEtaCharged[fgkNmcTypes]; 
  TH2F *       fhMCDeltaPhiChargedPt[fgkNmcTypes];       
  TH2F *       fhMCPtXECharged[fgkNmcTypes];             
  TH2F *       fhMCPtXEUeCharged[fgkNmcTypes];           
  TH2F *       fhMCPtXEUeLeftCharged[fgkNmcTypes];       
  TH2F *       fhMCPtHbpXECharged[fgkNmcTypes];          
  TH2F *       fhMCPtHbpXEUeCharged[fgkNmcTypes];        
  TH2F *       fhMCPtHbpXEUeLeftCharged[fgkNmcTypes];    
  TH1F *       fhMCUePart[fgkNmcTypes];                  
  TH2F *       fhMCPtZTCharged[fgkNmcTypes];             
  TH2F *       fhMCPtZTUeCharged[fgkNmcTypes];           
  TH2F *       fhMCPtZTUeLeftCharged[fgkNmcTypes];       
  TH2F *       fhMCPtHbpZTCharged[fgkNmcTypes];          
  TH2F *       fhMCPtHbpZTUeCharged[fgkNmcTypes];        
  TH2F *       fhMCPtHbpZTUeLeftCharged[fgkNmcTypes];    
  TH2F *       fhMCPtTrigPout[fgkNmcTypes];              
  TH2F *       fhMCPtAssocDeltaPhi[fgkNmcTypes];         
  
  // Mixing
  TH1I *       fhNEventsTrigger;                         
  TH2F *       fhNtracksMB;                              
  TH2F *       fhNclustersMB;                            
  TH2F *       fhMixDeltaPhiCharged;                     
  TH2F *       fhMixDeltaPhiDeltaEtaCharged;             
  TH2F *       fhMixXECharged;                           
  TH2F *       fhMixXEUeCharged;                         
  TH2F *       fhMixHbpXECharged;                        
  
  TH2F **      fhMixDeltaPhiChargedAssocPtBin;           
  
  TH2F **      fhMixDeltaPhiChargedAssocPtBinDEta08;     
  
  TH2F **      fhMixDeltaPhiChargedAssocPtBinDEta0;      
  
  TH3F **      fhMixDeltaPhiDeltaEtaChargedAssocPtBin;   
  
  TH1I *       fhEventBin;                               
  TH1I *       fhEventMixBin;                            
  TH1I *       fhEventMBBin;                             
  
  // Check invariant mass
  TH2F *       fhMassPtTrigger;                          
  TH2F *       fhMCMassPtTrigger[fgkNmcTypes];           
  
  // pT in isolation cone bins histograms
  
  TH1F **       fhPtLeadInConeBin;                       
  
  TH1F **       fhPtSumInConeBin ;                       
  
  TH1F **       fhPtLeadConeBinDecay;                    
  
  TH1F **       fhSumPtConeBinDecay;                     
  
  TH1F **       fhPtLeadConeBinMC;                       
  
  TH1F **       fhSumPtConeBinMC;                        
  
  TH2F *        fhTrackResolution;                       
  
  TH2F *        fhTrackResolutionUE;                     
  
  // Per SM histograms
  TH2F *       fhPtTriggerPerSM ;                        
  TH2F *       fhXEChargedPerSM      [20] ;              
  TH2F *       fhXEUeChargedPerSM    [20] ;              
  TH2F *       fhDeltaPhiChargedPerSM[20] ;              
  TH2F *       fhDeltaPhiChargedPtA3GeVPerSM[20] ;       

  TH2F *       fhPtTriggerPerTCardIndex ;                
  TH2F *       fhXEChargedPerTCardIndex      [16] ;      
  TH2F *       fhXEUeChargedPerTCardIndex    [16] ;      
  TH2F *       fhDeltaPhiChargedPerTCardIndex[16] ;      
  TH2F *       fhDeltaPhiChargedPtA3GeVPerTCardIndex[16];
  
  AliAnaParticleHadronCorrelation(              const AliAnaParticleHadronCorrelation & ph) ;
  
  AliAnaParticleHadronCorrelation & operator = (const AliAnaParticleHadronCorrelation & ph) ;
  
  ClassDef(AliAnaParticleHadronCorrelation,37) ;
  
} ;

#endif //ALIANAPARTICLEHADRONCORRELATION_H