AliAnaPi0.h

Go to the documentation of this file.

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

//_________________________________________________________________________
//_________________________________________________________________________

// Root
class TList;
class TH3F ;
class TH2F ;
class TObjString;

// Analysis
#include "AliAnaCaloTrackCorrBaseClass.h"
class AliAODEvent ;
class AliESDEvent ;
class AliAODPWG4Particle ;

class AliAnaPi0 : public AliAnaCaloTrackCorrBaseClass {
  
 public:   
  
  AliAnaPi0() ;
    
  virtual ~AliAnaPi0() ;
  
  //-------------------------------
  // General analysis frame methods
  //-------------------------------

  TObjString * GetAnalysisCuts();
  
  TList      * GetCreateOutputObjects(); 
  
  void         Print(const Option_t * opt) const;
  
  void         MakeAnalysisFillHistograms();
  
  void         InitParameters();
  
  //-------------------------------
  // EVENT Bin Methods
  //-------------------------------

  Int_t        GetEventIndex(AliAODPWG4Particle * part, Double_t * vert)  ;  

  //-------------------------------
  // Opening angle pair selection
  //-------------------------------
    
  void         SwitchOnAngleSelection()         { fUseAngleCut         = kTRUE  ; }
  void         SwitchOffAngleSelection()        { fUseAngleCut         = kFALSE ; }
  
  void         SwitchOnAngleEDepSelection()     { fUseAngleEDepCut     = kTRUE  ; }
  void         SwitchOffAngleEDepSelection()    { fUseAngleEDepCut     = kFALSE ; }
    
  void         SetAngleCut(Float_t a)           { fAngleCut            = a      ; }
  void         SetAngleMaxCut(Float_t a)        { fAngleMaxCut         = a      ; }

  void         SwitchOnFillAngleHisto()         { fFillAngleHisto      = kTRUE  ; }
  void         SwitchOffFillAngleHisto()        { fFillAngleHisto      = kFALSE ; }
  
  //------------------------------------------
  // Do analysis only with clusters in same SM or different combinations of SM
  //------------------------------------------
    
  void         SwitchOnSameSM()                 { fSameSM              = kTRUE  ; }
  void         SwitchOffSameSM()                { fSameSM              = kFALSE ; }
  
  void         SwitchOnSMCombinations()         { fFillSMCombinations  = kTRUE  ; }
  void         SwitchOffSMCombinations()        { fFillSMCombinations  = kFALSE ; }
  
  //-------------------------------
  // Histogram filling options off by default
  //-------------------------------
    
  void         SwitchOnInvPtWeight()            { fMakeInvPtPlots      = kTRUE  ; }
  void         SwitchOffInvPtWeight()           { fMakeInvPtPlots      = kFALSE ; }
  
  void         SwitchOnFillBadDistHisto()       { fFillBadDistHisto    = kTRUE  ; }
  void         SwitchOffFillBadDistHisto()      { fFillBadDistHisto    = kFALSE ; }

  void         SwitchOnFillOnlyMCAcceptanceHisto()  { fFillOnlyMCAcceptanceHisto    = kTRUE  ; }
  void         SwitchOffFillOnlyMCAcceptanceHisto() { fFillOnlyMCAcceptanceHisto    = kFALSE ; }
  
  //-------------------------------------------
  // Cuts for multiple analysis, off by default
  //-------------------------------------------
    
  void         SwitchOnMultipleCutAnalysis()    { fMultiCutAna         = kTRUE  ; }
  void         SwitchOffMultipleCutAnalysis()   { fMultiCutAna         = kFALSE ; }
  
  void         SwitchOnMultipleCutAcceptAnalysis()  { fMultiCutAnaAcc  = kTRUE  ; }
  void         SwitchOffMultipleCutAcceptAnalysis() { fMultiCutAnaAcc  = kFALSE ; }

  void         SetNPtCuts   (Int_t s)           { if(s <= 10)fNPtCuts    = s    ; }
  void         SetNAsymCuts (Int_t s)           { if(s <= 10)fNAsymCuts  = s    ; }
  void         SetNNCellCuts(Int_t s)           { if(s <= 10)fNCellNCuts = s    ; }
  void         SetNPIDBits  (Int_t s)           { if(s <= 10)fNPIDBits   = s    ; }
  void         SetNAngleCutBins(Int_t s)        { if(s <= 10)fNAngleCutBins = s ; }
  
  void         SetPtCutsAt   (Int_t p,Float_t v){ if(p < 11)fPtCuts[p]   = v    ; }
  void         SetPtCutsMaxAt(Int_t p,Float_t v){ if(p < 11)fPtCutsMax[p]= v    ; }
  void         SetAsymCutsAt (Int_t p,Float_t v){ if(p < 10)fAsymCuts[p] = v    ; }
  void         SetNCellCutsAt(Int_t p,Int_t v)  { if(p < 10)fCellNCuts[p]= v    ; }
  void         SetPIDBitsAt  (Int_t p,Int_t v)  { if(p < 10)fPIDBits[p]  = v    ; }
  void         SetAngleCutBin(Int_t p,Float_t v){ if(p < 10)fAngleCutBinsArray[p]= v; }
  
  void         SwitchOnFillSSCombinations()     { fFillSSCombinations  = kTRUE  ; }
  void         SwitchOffFillSSCombinations()    { fFillSSCombinations  = kFALSE ; }
  
  void         SwitchOnFillAsymmetryHisto()     { fFillAsymmetryHisto  = kTRUE  ; }
  void         SwitchOffFillAsymmetryHisto()    { fFillAsymmetryHisto  = kFALSE ; }

  void         SwitchOnFillOriginHisto()        { fFillOriginHisto     = kTRUE  ; }
  void         SwitchOffFillOriginHisto()       { fFillOriginHisto     = kFALSE ; }

  void         SwitchOnFillArmenterosThetaStarHisto()  { fFillArmenterosThetaStar = kTRUE  ; }
  void         SwitchOffFillArmenterosThetaStarHisto() { fFillArmenterosThetaStar = kFALSE ; }

  void         SwitchOnFillSecondaryCellTimeSel()      { fFillSecondaryCellTiming = kTRUE  ; }
  void         SwitchOffFillSecondaryCellTimeSel()     { fFillSecondaryCellTiming = kFALSE ; }
  
  void         SwitchOnFillOpAngleCutHisto()    { fFillOpAngleCutHisto = kTRUE  ; }
  void         SwitchOffFillOpAngleCutHisto()   { fFillOpAngleCutHisto = kFALSE ; }
  
  //-------------------------------------------
  // Pair 2 different inputs
  //-------------------------------------------

  void         SwitchOnPairWithOtherDetector() { fPairWithOtherDetector = kTRUE ; }    
  void         SwitchOffPairWithOtherDetector(){ fPairWithOtherDetector = kFALSE; } 
  void         SetOtherDetectorInputName(TString name)
  { fOtherDetectorInputName = name ;   if(name != "") SwitchOnPairWithOtherDetector() ; }

  // MC analysis related methods
    
  void         SwitchOnConversionChecker()      { fCheckConversion     = kTRUE  ; }
  void         SwitchOffConversionChecker()     { fCheckConversion     = kFALSE ; }  
  
  void         SwitchOnMultipleCutAnalysisInSimulation()  { fMultiCutAnaSim = kTRUE  ; }
  void         SwitchOffMultipleCutAnalysisInSimulation() { fMultiCutAnaSim = kFALSE ; }
  
  void         SwitchOnCheckAcceptanceInSector() { fCheckAccInSector   = kTRUE  ; }
  void         SwitchOffCheckAcceptanceInSector(){ fCheckAccInSector   = kFALSE ; }
  
  void         FillAcceptanceHistograms();
    
  void         FillMCVersusRecDataHistograms(Int_t ancLabel ,  Int_t    ancPDG, 
                                             Int_t ancStatus,  Double_t weightPt,
                                             Int_t    iclus1,  Int_t    iclus2,
                                             Int_t    mctag1,  Int_t    mctag2,
                                             Float_t  pt1,     Float_t  pt2,
                                             Int_t    ncells1, Int_t    ncells2,
                                             Double_t mass,    Double_t pt,     Double_t asym,
                                             Double_t deta,    Double_t dphi,   Double_t angle);
  
  void         SetPi0MassSelectionWindow(Float_t min, Float_t max) { fPi0MassWindow[0] = min ; fPi0MassWindow[1] = max ; }
  void         SetEtaMassSelectionWindow(Float_t min, Float_t max) { fEtaMassWindow[0] = min ; fEtaMassWindow[1] = max ; }
  
  void         FillArmenterosThetaStar(Int_t pdg);

  private:

  TList ** fEventsList ;               
  
  Bool_t   fUseAngleCut ;              
  Bool_t   fUseAngleEDepCut ;          
  Float_t  fAngleCut ;                 
  Float_t  fAngleMaxCut ;              
  
  Float_t  fPi0MassWindow[2];          
  Float_t  fEtaMassWindow[2];          
  
  // Multiple cuts analysis
  Bool_t   fMultiCutAna;               
  Bool_t   fMultiCutAnaSim;            
  Bool_t   fMultiCutAnaAcc;            
  Int_t    fNPtCuts;                   
  Float_t  fPtCuts[11];                
  Float_t  fPtCutsMax[11];             
  Int_t    fNAsymCuts;                 
  Float_t  fAsymCuts[10];              
  Int_t    fNCellNCuts;                
  Int_t    fCellNCuts[10];             
  Int_t    fNPIDBits ;                 
  Int_t    fPIDBits[10];               

  Int_t    fNAngleCutBins ;            
  Float_t  fAngleCutBinsArray[11];     
  
  // Switchs of different analysis options
  Bool_t   fMakeInvPtPlots;            
  Bool_t   fSameSM;                    
  Bool_t   fFillSMCombinations;        
  Bool_t   fCheckConversion;           
  Bool_t   fFillBadDistHisto;          
  Bool_t   fFillSSCombinations;        
  Bool_t   fFillAngleHisto;            
  Bool_t   fFillAsymmetryHisto;        
  Bool_t   fFillOriginHisto;           
  Bool_t   fFillArmenterosThetaStar;   
  Bool_t   fFillOnlyMCAcceptanceHisto; 
  Bool_t   fFillSecondaryCellTiming;   
  Bool_t   fFillOpAngleCutHisto;       
  
  Bool_t   fCheckAccInSector;          
  
  Bool_t   fPairWithOtherDetector;     
  TString  fOtherDetectorInputName;    
  
  TLorentzVector fPhotonMom1;          
  TLorentzVector fPhotonMom1Boost;     
  TLorentzVector fPhotonMom2;          
  TLorentzVector fMCPrimMesonMom;      
  TVector3       fMCProdVertex;        
    
  // ----------
  // Histograms
  // ----------
        
  TH2F **  fhReMod ;                   
    
  TH2F **  fhReSameSideEMCALMod ;      
    
  TH2F **  fhReSameSectorEMCALMod ;    
    
  TH2F **  fhReDiffPHOSMod ;           
    
  TH2F **  fhReSameSectorDCALPHOSMod ;    
  
  TH2F **  fhReDiffSectorDCALPHOSMod ;    
  
  TH2F **  fhMiMod ;                   
    
  TH2F **  fhMiSameSideEMCALMod ;      
    
  TH2F **  fhMiSameSectorEMCALMod ;    
    
  TH2F **  fhMiDiffPHOSMod ;           
  
  TH2F **  fhMiSameSectorDCALPHOSMod ;    
  
  TH2F **  fhMiDiffSectorDCALPHOSMod ;    

  // Pairs with at least one cluster tagged as conversion
    
  TH2F *   fhReConv ;                  
  TH2F *   fhMiConv ;                  
  TH2F *   fhReConv2 ;                 
  TH2F *   fhMiConv2 ;                 

  TH2F **  fhRe1 ;                     
    
  TH2F **  fhMi1 ;                     
    
  TH2F **  fhRe2 ;                     
    
  TH2F **  fhMi2 ;                     
    
  TH2F **  fhRe3 ;                     

  TH2F **  fhMi3 ;                     

  // Histograms weighted by inverse pT
    
  TH2F **  fhReInvPt1 ;                
    
  TH2F **  fhMiInvPt1 ;                
    
  TH2F **  fhReInvPt2 ;                
  
  TH2F **  fhMiInvPt2 ;                

  TH2F **  fhReInvPt3 ;                
    
  TH2F **  fhMiInvPt3 ;                
  
  // Multiple cuts: Assymmetry, pt, n cells, PID
    
  TH2F **  fhRePtNCellAsymCuts ;       
    
  TH2F **  fhMiPtNCellAsymCuts ;       
    
  TH2F **  fhRePtNCellAsymCutsSM[20] ; 

  TH2F **  fhRePtNCellAsymCutsOpAngle ;       
  
  TH2F **  fhMiPtNCellAsymCutsOpAngle ;       
  
  TH2F **  fhRePtNCellAsymCutsSMOpAngle[20] ; 

  TH2F *   fhReSS[3] ;                 
    
  // Asymmetry vs pt, in pi0/eta regions
    
  TH2F *   fhRePtAsym    ;             
  TH2F *   fhRePtAsymPi0 ;             
  TH2F *   fhRePtAsymEta ;             
  TH2F *   fhMiPtAsym    ;             
  TH2F *   fhMiPtAsymPi0 ;             
  TH2F *   fhMiPtAsymEta ;             
  
  // Centrality, Event plane bins
    
  TH1I *   fhEventBin;                 
  TH1I *   fhEventMixBin;              
  TH1F *   fhCentrality;               
  TH1F *   fhCentralityNoPair;         

  TH2F *   fhEventPlaneResolution;     
  
  // Pair opening angle
    
  TH2F *   fhRealOpeningAngle ;        
  TH2F *   fhRealCosOpeningAngle ;     
  TH2F *   fhMixedOpeningAngle ;       
  TH2F *   fhMixedCosOpeningAngle ;    
  
  TH2F *   fhRealOpeningAnglePerSM [20]; 
  TH2F *   fhMixedOpeningAnglePerSM[20]; 
  
  // MC analysis histograms
  // Pi0 Acceptance
    
  TH1F *   fhPrimPi0E ;                
  TH1F *   fhPrimPi0Pt ;               
  TH1F *   fhPrimPi0PtInCalo ;         
  TH1F *   fhPrimPi0AccE ;             
  TH1F *   fhPrimPi0AccPt ;            
  TH1F *   fhPrimPi0AccPtPhotonCuts ;  
  TH1F *   fhPrimPi0AccPtOpAngCuts[10];
  TH2F *   fhPrimPi0Y ;                
  TH2F *   fhPrimPi0AccY ;             
  TH2F *   fhPrimPi0Yeta ;             
  TH2F *   fhPrimPi0YetaYcut ;         
  TH2F *   fhPrimPi0AccYeta ;          
  TH2F *   fhPrimPi0Phi ;              
  TH2F *   fhPrimPi0AccPhi;            
  TH2F *   fhPrimPi0OpeningAngle ;     
  TH2F *   fhPrimPi0OpeningAnglePhotonCuts ; 
  TH2F *   fhPrimPi0OpeningAngleAsym ; 
  TH2F *   fhPrimPi0CosOpeningAngle ;  
  TH2F *   fhPrimPi0PtCentrality ;     
  TH2F *   fhPrimPi0PtEventPlane ;     
  TH2F *   fhPrimPi0AccPtCentrality ;  
  TH2F *   fhPrimPi0AccPtEventPlane ;  

  // Eta acceptance
    
  TH1F *   fhPrimEtaE ;                
  TH1F *   fhPrimEtaPt ;               
  TH1F *   fhPrimEtaPtInCalo ;         
  TH1F *   fhPrimEtaAccE ;             
  TH1F *   fhPrimEtaAccPt ;            
  TH1F *   fhPrimEtaAccPtPhotonCuts ;  
  TH1F *   fhPrimEtaAccPtOpAngCuts[10];
  TH2F *   fhPrimEtaY ;                
  TH2F *   fhPrimEtaAccY ;             
  TH2F *   fhPrimEtaYeta ;             
  TH2F *   fhPrimEtaYetaYcut ;         
  TH2F *   fhPrimEtaAccYeta ;          
  TH2F *   fhPrimEtaPhi ;              
  TH2F *   fhPrimEtaAccPhi;            
  TH2F *   fhPrimEtaOpeningAngle ;     
  TH2F *   fhPrimEtaOpeningAnglePhotonCuts ; 
  TH2F *   fhPrimEtaOpeningAngleAsym ; 
  TH2F *   fhPrimEtaCosOpeningAngle ;  
  TH2F *   fhPrimEtaPtCentrality ;     
  TH2F *   fhPrimEtaPtEventPlane ;     
  TH2F *   fhPrimEtaAccPtCentrality ;  
  TH2F *   fhPrimEtaAccPtEventPlane ;  
  
  // Primaries origin
    
  TH2F *   fhPrimPi0PtOrigin ;         
  TH2F *   fhPrimEtaPtOrigin ;         
  TH2F *   fhPrimNotResonancePi0PtOrigin ; 
  TH2F *   fhPrimPi0PtStatus ;         

  // Per Generator in Cocktail
  TH1F *   fhPrimPi0PtPerGenerator[10] ;               
  TH1F *   fhPrimPi0PtInCaloPerGenerator[10] ;         
  TH1F *   fhPrimPi0AccPtPerGenerator[10] ;            
  TH1F *   fhPrimPi0AccPtPhotonCutsPerGenerator[10] ;  
  TH2F *   fhPrimPi0PhiPerGenerator[10] ;              
  TH2F *   fhPrimPi0YPerGenerator[10] ;                

  TH1F *   fhPrimEtaPtPerGenerator[10] ;               
  TH1F *   fhPrimEtaPtInCaloPerGenerator[10] ;         
  TH1F *   fhPrimEtaAccPtPerGenerator[10] ;            
  TH1F *   fhPrimEtaAccPtPhotonCutsPerGenerator[10] ;  
  TH2F *   fhPrimEtaPhiPerGenerator[10] ;              
  TH2F *   fhPrimEtaYPerGenerator[10] ;                
  
  // Pair origin
  // Array of histograms ordered as follows: 0-Photon, 1-electron, 2-pi0, 3-eta, 4-a-proton, 5-a-neutron, 6-stable particles,
  // 7-other decays, 8-string, 9-final parton, 10-initial parton, intermediate, 11-colliding proton, 
  // 12-pi0 non gamma-gamma, 13-eta non gamma-gamma, 14-gamma-not conversion, 15-electron-not conversion 16-unrelated
    
  TH2F *   fhMCOrgMass[17];            
  TH2F *   fhMCOrgAsym[17];            
  TH2F *   fhMCOrgDeltaEta[17];        
  TH2F *   fhMCOrgDeltaPhi[17];        
  
  // Multiple cuts in simulation, origin pi0 or eta
    
  TH2F **  fhMCPi0MassPtRec;           
  
  TH2F **  fhMCPi0MassPtTrue;          
    
  TH2F **  fhMCPi0PtTruePtRec;         
  
  TH2F **  fhMCPi0PtTruePtRecMassCut;  
  
  TH2F **  fhMCEtaMassPtRec;           
  
  TH2F **  fhMCEtaMassPtTrue;          
    
  TH2F **  fhMCEtaPtTruePtRec;         

  TH2F **  fhMCEtaPtTruePtRecMassCut;  

  TH2F *   fhMCPi0PerCentrality;       
  TH2F *   fhMCPi0PerCentralityMassCut;
  TH2F *   fhMCEtaPerCentrality;       
  TH2F *   fhMCEtaPerCentralityMassCut;
  
  TH2F *   fhMCPi0PtTruePtRecRat;      
  TH2F *   fhMCPi0PtTruePtRecDif;      
  TH2F *   fhMCPi0PtRecOpenAngle;      
  
  TH2F *   fhMCEtaPtTruePtRecRat;      
  TH2F *   fhMCEtaPtTruePtRecDif;      
  TH2F *   fhMCEtaPtRecOpenAngle;      

  TH2F *   fhMCPi0PtTruePtRecRatMassCut; 
  TH2F *   fhMCPi0PtTruePtRecDifMassCut; 
  TH2F *   fhMCPi0PtRecOpenAngleMassCut; 
  
  TH2F *   fhMCEtaPtTruePtRecRatMassCut; 
  TH2F *   fhMCEtaPtTruePtRecDifMassCut; 
  TH2F *   fhMCEtaPtRecOpenAngleMassCut; 
  
  TH2F *   fhMCPi0PtOrigin ;           
  TH2F *   fhMCEtaPtOrigin ;           
  TH2F *   fhMCNotResonancePi0PtOrigin;
  TH2F *   fhMCPi0PtStatus ;           

  TH2F *   fhMCPi0ProdVertex;          
  TH2F *   fhMCEtaProdVertex;          
  TH2F *   fhPrimPi0ProdVertex;        
  TH2F *   fhPrimEtaProdVertex;        

  TH2F *   fhMCPi0Radius[10] ;         
  TH2F *   fhMCEtaRadius[6] ;          

  
  TH2F *   fhReMCFromConversion ;      
  TH2F *   fhReMCFromNotConversion ;   
  TH2F *   fhReMCFromMixConversion ;   

  TH2F *   fhArmPrimPi0[4];            
  TH2F *   fhArmPrimEta[4];            
  TH2F *   fhCosThStarPrimPi0;         
  TH2F *   fhCosThStarPrimEta;         
  
  TH2F *   fhEPairDiffTime;            
  
  // Select clusters depending on cell time content
  TH2F * fhReSecondaryCellInTimeWindow; 
  TH2F * fhMiSecondaryCellInTimeWindow; 
  TH2F * fhReSecondaryCellOutTimeWindow;
  TH2F * fhMiSecondaryCellOutTimeWindow;
  
  // Cluster pair studies depending on opening angle
  TH2F *  fhReOpAngleBinMinClusterEtaPhi       [10] ; 
  TH2F *  fhReOpAngleBinMaxClusterEtaPhi       [10] ; 
  TH2F *  fhReOpAngleBinMinClusterColRow       [10] ; 
  TH2F *  fhReOpAngleBinMaxClusterColRow       [10] ; 
  TH2F *  fhReOpAngleBinMinClusterEPerSM       [10] ; 
  TH2F *  fhReOpAngleBinMaxClusterEPerSM       [10] ; 
  TH2F *  fhReOpAngleBinMinClusterTimePerSM    [10] ; 
  TH2F *  fhReOpAngleBinMaxClusterTimePerSM    [10] ; 
  TH2F *  fhReOpAngleBinMinClusterNCellPerSM   [10] ; 
  TH2F *  fhReOpAngleBinMaxClusterNCellPerSM   [10] ; 
  TH2F *  fhReOpAngleBinPairClusterRatioPerSM  [10] ; 
  TH2F *  fhReOpAngleBinPairClusterMass        [10] ; 
  TH2F *  fhReOpAngleBinPairClusterMassPerSM   [10] ; 
//  TH2F *  fhReOpAngleBinPairClusterAbsIdMaxCell[10] ; //!<! Cluster cell with maximum energy in one selected photon vs the other 

  TH2F *  fhReOpAngleBinPairClusterMassMCTruePi0[10] ; 
  TH2F *  fhReOpAngleBinPairClusterMassMCTrueEta[10] ; 
  
  TH2F *  fhMiOpAngleBinMinClusterEtaPhi       [10] ; 
  TH2F *  fhMiOpAngleBinMaxClusterEtaPhi       [10] ; 
//TH2F *  fhMiOpAngleBinMinClusterColRow       [10] ; //!<! Column and row location of main cell of lowest energy cluster in pair, depending on opening angle cut, mixed event
//TH2F *  fhMiOpAngleBinMaxClusterColRow       [10] ; //!<! Column and row location of main cell of highest energy cluster in pair, depending on opening angle cut, mixed event
  TH2F *  fhMiOpAngleBinMinClusterEPerSM       [10] ; 
  TH2F *  fhMiOpAngleBinMaxClusterEPerSM       [10] ; 
  TH2F *  fhMiOpAngleBinMinClusterTimePerSM    [10] ; 
  TH2F *  fhMiOpAngleBinMaxClusterTimePerSM    [10] ; 
  TH2F *  fhMiOpAngleBinMinClusterNCellPerSM   [10] ; 
  TH2F *  fhMiOpAngleBinMaxClusterNCellPerSM   [10] ; 
  TH2F *  fhMiOpAngleBinPairClusterRatioPerSM  [10] ; 
  TH2F *  fhMiOpAngleBinPairClusterMass        [10] ; 
  TH2F *  fhMiOpAngleBinPairClusterMassPerSM   [10] ; 
//TH2F *  fhMiOpAngleBinPairClusterAbsIdMaxCell[10] ; //!<! Cluster cell with maximum energy in one selected photon vs the other, mixed event 
  
  TH2F *  fhPtBinClusterEtaPhi                 [10] ; 
  TH2F *  fhPtBinClusterColRow                 [10] ; 

  TH2F *  fhPairGeneratorsBkgMass               [10][10]; 
  TH2F *  fhPairGeneratorsBkgMassMCPi0          [10][10]; 
  TH2F *  fhPairGeneratorsBkgCentMCPi0          [10][10]; 
  TH2F *  fhPairGeneratorsBkgCentMCPi0MassCut   [10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoRatioMCPi0[10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoDiffMCPi0 [10][10]; 
  TH2F *  fhPairGeneratorsBkgMassMCEta          [10][10]; 
  TH2F *  fhPairGeneratorsBkgCentMCEta          [10][10]; 
  TH2F *  fhPairGeneratorsBkgCentMCEtaMassCut   [10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoRatioMCEta[10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoDiffMCEta [10][10]; 
  
  TH2F *  fhPairGeneratorsBkgEPrimRecoRatioMCPi0MassCut[10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoDiffMCPi0MassCut [10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoRatioMCEtaMassCut[10][10]; 
  TH2F *  fhPairGeneratorsBkgEPrimRecoDiffMCEtaMassCut [10][10]; 
  
  AliAnaPi0(              const AliAnaPi0 & api0) ;
   
  AliAnaPi0 & operator = (const AliAnaPi0 & api0) ;
  
  ClassDef(AliAnaPi0,35) ;
  
} ;

#endif //ALIANAPI0_H