AliAnalysisTaskGammaCaloIso.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKGammaCaloIso_cxx
#define ALIANLYSISTASKGammaCaloIso_cxx

#include "AliAnalysisTaskSE.h"
#include "AliESDtrack.h"
#include "AliV0ReaderV1.h"
#include "AliKFConversionPhoton.h"
#include "AliGammaConversionAODBGHandler.h"
#include "AliConversionAODBGHandlerRP.h"
#include "AliCaloPhotonCuts.h"
#include "AliConvEventCuts.h"
#include "AliConversionPhotonCuts.h"
#include "AliConversionMesonCuts.h"
#include "AliAnalysisTaskConvJet.h"
#include "AliAnalysisManager.h"
#include "TProfile2D.h"
#include "TH3.h"
#include "TH3F.h"
#include <vector>
#include <map>

class AliAnalysisTaskGammaCaloIso : public AliAnalysisTaskSE {
  public:

    AliAnalysisTaskGammaCaloIso();
    AliAnalysisTaskGammaCaloIso(const char *name);
    virtual ~AliAnalysisTaskGammaCaloIso();

    virtual void   UserCreateOutputObjects();
    virtual Bool_t Notify();
    virtual void   UserExec(Option_t *);
    virtual void   Terminate(const Option_t*);
    void InitBack();

    void SetV0ReaderName(TString name){fV0ReaderName=name; return;}
    void SetIsHeavyIon(Int_t flag){
      fIsHeavyIon = flag;
    }

    // base functions for selecting photon and meson candidates in reconstructed data
    void ProcessClusters();
    void ProcessJets();
    void CalculatePi0Candidates();
    void CalculatePi0CandidatesIsolation();

    // MC functions
    void SetIsMC(Int_t isMC){fIsMC=isMC;}
    void ProcessMCParticles();
    void ProcessAODMCParticles();
    void ProcessTrueClusterCandidates( AliAODConversionPhoton* TruePhotonCandidate, AliVCluster* clus);
    void ProcessTrueClusterCandidatesAOD( AliAODConversionPhoton* TruePhotonCandidate, AliVCluster* clus);
    void ProcessTrueMesonCandidates( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
    void ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
    void ProcessMCParticlesIsolationAOD(AliVCluster *cluster, AliAODConversionPhoton *photoncandidate);


    // switches for additional analysis streams or outputs
    void SetLightOutput(Bool_t flag){fDoLightOutput = flag;}
    void SetDoMesonAnalysis(Bool_t flag){fDoMesonAnalysis = flag;}
    void SetDoMesonQA(Int_t flag){fDoMesonQA = flag;}
    void SetDoClusterQA(Int_t flag){fDoClusterQA = flag;}
    void SetDoTHnSparse(Bool_t flag){fDoTHnSparse = flag;}
    void SetPlotHistsExtQA(Bool_t flag){fSetPlotHistsExtQA = flag;}
    void SetAllowOverlapHeaders( Bool_t allowOverlapHeader ) {fAllowOverlapHeaders = allowOverlapHeader;}

    void SetInOutTimingCluster(Double_t min, Double_t max){
      fDoInOutTimingCluster = kTRUE; fMinTimingCluster = min; fMaxTimingCluster = max;
      return;
    }

      // Setting the cut lists for the conversion photons
    void SetEventCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fEventCutArray = CutArray;
    }

      // Setting the cut lists for the calo photons
    void SetCaloCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fClusterCutArray = CutArray;
    }

    // Setting the cut lists for the meson
    void SetMesonCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fMesonCutArray = CutArray;
    }

    // BG HandlerSettings
    void CalculateBackground();
    void CalculateBackgroundIsolation();
    void CalculateBackgroundRP();
    void RotateParticle(AliAODConversionPhoton *gamma);
    void RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP);
    void FillPhotonBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode);
    void FillPhotonPlusConversionBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode);
    void FillPhotonBackgroundM02Hist(AliAODConversionPhoton *TruePhotonCandidate, AliVCluster* clus, Int_t pdgCode);
    void FillPhotonPlusConversionBackgroundM02Hist(AliAODConversionPhoton *TruePhotonCandidate, AliVCluster* clus, Int_t pdgCode);
    void UpdateEventByEventData();

    // Additional functions for convenience
    void SetLogBinningXTH2(TH2* histoRebin);
    Int_t GetSourceClassification(Int_t daughter, Int_t pdgCode);

    Bool_t CheckVectorForDoubleCount(vector<Int_t> &vec, Int_t tobechecked);
    void FillMultipleCountMap(map<Int_t,Int_t> &ma, Int_t tobechecked);
    void FillMultipleCountHistoAndClear(map<Int_t,Int_t> &ma, TH1F* hist);

    // set method to enable EOverP tree
    void SetProduceTreeEOverP(Bool_t b){fProduceTreeEOverP = b;}

    // Function to enable MC label sorting
    void SetEnableSortingOfMCClusLabels(Bool_t enableSort)  { fEnableSortForClusMC   = enableSort; }

    // Function to enable local debugging mode
    void SetLocalDebugFlag(Int_t iF) {fLocalDebugFlag = iF;}

    // Function to set correction task setting
    void SetCorrectionTaskSetting(TString setting) {fCorrTaskSetting = setting;}

    void EventDebugMethod();
    void DebugMethod(AliAODConversionMother *pi0cand, AliAODConversionPhoton *gamma0, AliAODConversionPhoton *gamma1);
    void DebugMethodPrint1(AliAODConversionMother *pi0cand, AliAODConversionPhoton *gamma0, AliAODConversionPhoton *gamma1);

    void SetTrackMatcherRunningMode(Int_t mode){fTrackMatcherRunningMode = mode;}

    void SetSoftAnalysis(Bool_t DoSoft)  {fDoSoftAnalysis = DoSoft;}

  protected:
    AliV0ReaderV1*        fV0Reader;                                            // basic photon Selection Task
    TString               fV0ReaderName;
    TString               fCorrTaskSetting;
    AliGammaConversionAODBGHandler**  fBGHandler;                               // BG handler for Conversion
    AliVEvent*            fInputEvent;                                          // current event
    AliMCEvent*           fMCEvent;                                             // corresponding MC event
    TList**               fCutFolder;                                           // Array of lists for containers belonging to cut
    TList**               fESDList;                                             // Array of lists with histograms with reconstructed properties
    TList**               fIsolation;                                           // Container for Photon Isolation
    TList**               fBackList;                                            // Array of lists with BG THnSparseF
    TList**               fMotherList;                                          // Array of lists with Signal THnSparseF
    TList**               fTrueList;                                            // Array of lists with histograms with MC validated reconstructed properties
    TList**               fMCList;                                              // Array of lists with histograms with pure MC information
    TList**               fTreeList;                                            // Array of lists with tree for validated MC
    TList**               fClusterTreeList;                                     // Array of lists with tree for EoverP
    TList*                fOutputContainer;                                     // Output container
    TList*                fClusterCandidates;                                   
    TList*                fIsoCandidates;                                       
    TList*                fEventCutArray;                                       // List with Event Cuts
    AliConvEventCuts*     fEventCuts;                                           // EventCutObject
    TList*                fClusterCutArray;                                     // List with Cluster Cuts
    AliCaloPhotonCuts*    fCaloPhotonCuts;                                      // CaloPhotonCutObject
    TList*                fMesonCutArray;                                       // List with Meson Cuts
    AliConversionMesonCuts*   fMesonCuts;                                       // MesonCutObject
    AliAnalysisTaskConvJet*   fConvJetReader;                                   // JetReader
    Bool_t                fDoJetAnalysis;                                       // Bool to produce Jet Plots
    Bool_t                fDoJetQA;                                             // Bool to produce Jet QA Plots
    TList**               fJetHistograms;                                       // Jet Histograms
    TList**               fTrueJetHistograms;                                   // True Jet Histograms

    //histograms for mesons reconstructed quantities
    TH2F**                fHistoMotherInvMassPt;                                
    TH2F**                fHistoMotherInvMassIsoPt;                             
    THnSparseF**          fSparseMotherInvMassPtZM;                             
    TH2F**                fHistoMotherBackInvMassPt;                            
    TH2F**                fHistoMotherBackInvMassIsoPt;                         
    THnSparseF**          fSparseMotherBackInvMassPtZM;                         
    TH2F**                fHistoMotherPi0PtY;                                   
    TH2F**                fHistoMotherEtaPtY;                                   
    TH2F**                fHistoMotherPi0PtAlpha;                               
    TH2F**                fHistoMotherEtaPtAlpha;                               
    TH2F**                fHistoMotherPi0PtOpenAngle;                           
    TH2F**                fHistoMotherEtaPtOpenAngle;                           
    TH2F**                fHistoMotherPtOpenAngle;                              
    TH2F**                fHistoMotherPtOpenAngleBck;                           
    TH2F**                fHistoMotherPi0NGoodESDTracksPt;                 
    TH2F**                fHistoMotherEtaNGoodESDTracksPt;                 
    TH2F**                fHistoMotherInvMassECalib;        
    TH2F**                fHistoMotherBackInvMassECalib;      

    // histograms for Isolation
    TH1F**                  fHistoClusterCandidates;            
    TH1F**                  fHistoFailIsolationCut;             
    TH2F**                  fHistoIsoClusterPDGtoPt;            
    TH2F**                  fHistoIsoClusterPDGtoPtMatSec;      
    TH2F**                  fHistoIsoMotherPDGtoPt;             
    TH1F**                  fHistoIsoMatSecConversionfromPhoton;
    TH1F**                  fHistoIsoPhotonfromPi0;             
    TH1F**                  fHistoIsoInitPhotons;               
    TH1F**                  fHistoIsoFragPhotons;               
    TH1F**                  fHistoIsoInitPhotonsConversionCorrection;         
    vector<Int_t>           fVectorDoubleCountMCInitIsoPhotons;               
    TH1F**                  fHistoDoubleCountMCIsoInitPhotonCorrectPt;        
    TH1F**                  fHistoDoubleCountMCIsoInitPhotonPt;               

    // histograms for rec photon clusters
    TH1F**                fHistoClusGammaPt;                                    
    TH1F**                fHistoClusGammaE;                                     
    TH1F**                fHistoClusOverlapHeadersGammaPt;                      
    TH1F**                fHistoClusAllHeadersGammaPt;                          
    TH1F**                fHistoClusRejectedHeadersGammaPt;                     
    TH2F**                fHistoClusGammaPtM02;                                 
    //histograms for pure MC quantities
    TH1I**                fHistoMCHeaders;                                      
    TH1F**                fHistoMCAllGammaPt;                                   
    TH2F**                fHistoMCAllSecondaryGammaPt;                          
    TH1F**                fHistoMCDecayGammaPi0Pt;                              
    TH1F**                fHistoMCDecayGammaRhoPt;                              
    TH1F**                fHistoMCDecayGammaEtaPt;                              
    TH1F**                fHistoMCDecayGammaOmegaPt;                            
    TH1F**                fHistoMCDecayGammaEtapPt;                             
    TH1F**                fHistoMCDecayGammaPhiPt;                              
    TH1F**                fHistoMCDecayGammaSigmaPt;                            
    TH1F**                fHistoMCPi0Pt;                                        
    TH1F**                fHistoMCPi0WOWeightPt;                                
    TH1F**                fHistoMCPi0WOEvtWeightPt;                             
    TH1F**                fHistoMCEtaPt;                                        
    TH1F**                fHistoMCEtaWOWeightPt;                                
    TH1F**                fHistoMCEtaWOEvtWeightPt;                             
    TH1F**                fHistoMCPi0InAccPt;                                   
    TH1F**                fHistoMCEtaInAccPt;                                   
    TH1F**                fHistoMCPi0WOEvtWeightInAccPt;                        
    TH1F**                fHistoMCEtaWOEvtWeightInAccPt;                        
    TH2F**                fHistoMCPi0PtY;                                       
    TH2F**                fHistoMCEtaPtY;                                       
    TH2F**                fHistoMCPi0PtAlpha;                                   
    TH2F**                fHistoMCEtaPtAlpha;                                   
    TH2F**                fHistoMCPrimaryPtvsSource;                            
    TH2F**                fHistoMCSecPi0PtvsSource;                             
    TH1F**                fHistoMCSecPi0Source;                                 
    TH2F**                fHistoMCSecPi0InAccPtvsSource;                        
    TH1F**                fHistoMCSecEtaPt;                                     
    TH1F**                fHistoMCSecEtaSource;                                 
    TH2F**                fHistoMCPi0PtJetPt;                                   
    TH2F**                fHistoMCEtaPtJetPt;                                   

    // MC validated reconstructed quantities mesons
    TH2F**                fHistoTruePi0InvMassPt;                               
    TH2F**                fHistoTrueEtaInvMassPt;                               
    TH2F**                fHistoTruePi0CaloPhotonInvMassPt;                     
    TH2F**                fHistoTrueEtaCaloPhotonInvMassPt;                     
    TH2F**                fHistoTruePi0CaloConvertedPhotonInvMassPt;            
    TH2F**                fHistoTrueEtaCaloConvertedPhotonInvMassPt;            
    TH2F**                fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt;      
    TH2F**                fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt;      
    TH2F**                fHistoTruePi0CaloElectronInvMassPt;                   
    TH2F**                fHistoTrueEtaCaloElectronInvMassPt;                   
    TH2F**                fHistoTruePi0CaloMergedClusterInvMassPt;              
    TH2F**                fHistoTrueEtaCaloMergedClusterInvMassPt;              
    TH2F**                fHistoTruePi0CaloMergedClusterPartConvInvMassPt;      
    TH2F**                fHistoTrueEtaCaloMergedClusterPartConvInvMassPt;      
    TH2F**                fHistoTruePi0NonMergedElectronPhotonInvMassPt;        
    TH2F**                fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt;  
    TH2F**                fHistoTruePi0Category1;                               
    TH2F**                fHistoTrueEtaCategory1;                               
    TH2F**                fHistoTruePi0Category2;                               
    TH2F**                fHistoTrueEtaCategory2;                               
    TH2F**                fHistoTruePi0Category3;                               
    TH2F**                fHistoTrueEtaCategory3;                               
    TH2F**                fHistoTruePi0Category4_6;                             
    TH2F**                fHistoTrueEtaCategory4_6;                             
    TH2F**                fHistoTruePi0Category5;                               
    TH2F**                fHistoTrueEtaCategory5;                               
    TH2F**                fHistoTruePi0Category7;                               
    TH2F**                fHistoTrueEtaCategory7;                               
    TH2F**                fHistoTruePi0Category8;                               
    TH2F**                fHistoTrueEtaCategory8;                               
    TH2F**                fHistoTruePrimaryPi0InvMassPt;                        
    TH2F**                fHistoTruePrimaryEtaInvMassPt;                        
    TH2F**                fHistoTruePrimaryPi0W0WeightingInvMassPt;             
    TH2F**                fHistoTruePrimaryEtaW0WeightingInvMassPt;             
    TProfile2D**          fProfileTruePrimaryPi0WeightsInvMassPt;               
    TProfile2D**          fProfileTruePrimaryEtaWeightsInvMassPt;               
    TH2F**                fHistoTruePrimaryPi0MCPtResolPt;                      
    TH2F**                fHistoTruePrimaryEtaMCPtResolPt;                      
    TH2F**                fHistoTrueSecondaryPi0InvMassPt;                      
    TH2F**                fHistoTrueSecondaryPi0FromK0sInvMassPt;               
    TH1F**                fHistoTrueK0sWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromK0lInvMassPt;               
    TH1F**                fHistoTrueK0lWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromEtaInvMassPt;               
    TH1F**                fHistoTrueEtaWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromLambdaInvMassPt;            
    TH1F**                fHistoTrueLambdaWithPi0DaughterMCPt;                  
    TH2F**                fHistoTrueBckGGInvMassPt;                             
    TH2F**                fHistoTrueBckFullMesonContainedInOneClusterInvMassPt; 
    TH2F**                fHistoTrueBckAsymEClustersInvMassPt;                  
    TH2F**                fHistoTrueBckContInvMassPt;                           
    TH2F**                fHistoTruePi0PtY;                                     
    TH2F**                fHistoTrueEtaPtY;                                     
    TH2F**                fHistoTruePi0PtAlpha;                                 
    TH2F**                fHistoTrueEtaPtAlpha;                                 
    TH2F**                fHistoTruePi0PtOpenAngle;                             
    TH2F**                fHistoTrueEtaPtOpenAngle;                             
    // MC validated reconstructed quantities photons
    TH2F**                fHistoClusPhotonBGPt;                                 
    TH2F**                fHistoClusPhotonPlusConvBGPt;                         
    TH2F**                fHistoClustPhotonElectronBGPtM02;                     
    TH2F**                fHistoClustPhotonPionBGPtM02;                         
    TH2F**                fHistoClustPhotonKaonBGPtM02;                         
    TH2F**                fHistoClustPhotonK0lBGPtM02;                          
    TH2F**                fHistoClustPhotonNeutronBGPtM02;                      
    TH2F**                fHistoClustPhotonRestBGPtM02;                         
    TH2F**                fHistoClustPhotonPlusConvElectronBGPtM02;             
    TH2F**                fHistoClustPhotonPlusConvPionBGPtM02;                 
    TH2F**                fHistoClustPhotonPlusConvKaonBGPtM02;                 
    TH2F**                fHistoClustPhotonPlusConvK0lBGPtM02;                  
    TH2F**                fHistoClustPhotonPlusConvNeutronBGPtM02;              
    TH2F**                fHistoClustPhotonPlusConvRestBGPtM02;                 
    TH1F**                fHistoTrueClusGammaPt;                                
    TH1F**                fHistoTrueClusUnConvGammaPt;                          
    TH1F**                fHistoTrueClusUnConvGammaMCPt;                        
    TH2F**                fHistoTrueClusGammaPtM02;                             
    TH2F**                fHistoTrueClusUnConvGammaPtM02;                       
    TH1F**                fHistoTrueClusElectronPt;                             
    TH1F**                fHistoTrueClusConvGammaPt;                            
    TH1F**                fHistoTrueClusConvGammaMCPt;                          
    TH1F**                fHistoTrueClusConvGammaFullyPt;                       
    TH1F**                fHistoTrueClusMergedGammaPt;                          
    TH1F**                fHistoTrueClusMergedPartConvGammaPt;                  
    TH1F**                fHistoTrueClusDalitzPt;                               
    TH1F**                fHistoTrueClusDalitzMergedPt;                         
    TH1F**                fHistoTrueClusPhotonFromElecMotherPt;                 
    TH1F**                fHistoTrueClusShowerPt;                               
    TH1F**                fHistoTrueClusSubLeadingPt;                           
    TH1F**                fHistoTrueClusNParticles;                             
    TH1F**                fHistoTrueClusEMNonLeadingPt;                         
    TH1F**                fHistoTrueNLabelsInClus;                              
    TH1F**                fHistoTruePrimaryClusGammaPt;                         
    TH2F**                fHistoTruePrimaryClusGammaESDPtMCPt;                  
    TH1F**                fHistoTruePrimaryClusConvGammaPt;                     
    TH2F**                fHistoTruePrimaryClusConvGammaESDPtMCPt;              
    TH2F**                fHistoTrueSecondaryClusGammaPt;                       
    TH2F**                fHistoTrueSecondaryClusConvGammaPt;                   
    TH2F**                fHistoTrueSecondaryClusGammaMCPt;                     
    TH2F**                fHistoTrueSecondaryClusConvGammaMCPt;                 
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromK0sMCPtESDPt;        
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromK0sMCPtESDPt;    
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromK0lMCPtESDPt;        
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromK0lMCPtESDPt;    
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromLambdaMCPtESDPt;     
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromLambdaMCPtESDPt; 
    TH2F**                fHistoDoubleCountTruePi0InvMassPt;                    
    TH2F**                fHistoDoubleCountTrueEtaInvMassPt;                    
    TH2F**                fHistoDoubleCountTrueClusterGammaPt;                  
    vector<Int_t>         fVectorDoubleCountTruePi0s;                           
    vector<Int_t>         fVectorDoubleCountTrueEtas;                           
    vector<Int_t>         fVectorDoubleCountTrueClusterGammas;                  
    TH1F**                fHistoMultipleCountTrueClusterGamma;                  
    map<Int_t,Int_t>      fMapMultipleCountTrueClusterGammas;                   
    TH2F**                fHistoTruePi0InvMassPtAlpha;                          
    TH2F**                fHistoTruePi0PureGammaInvMassPtAlpha;                 
    TH2F**                fHistCellIDvsClusterEnergy;                           
    TH2F**                fHistCellIDvsClusterEnergyMax;                        

    // event histograms
    TH1F**                fHistoNEvents;                                        
    TH1F**                fHistoNEventsWOWeight;                                
    TH1F**                fHistoNGoodESDTracks;                                 
    TH1F**                fHistoVertexZ;                                        
    TH1F**                fHistoNGammaCandidates;                               
    TH1F**                fHistoNGammaCandidatesBasic;                          
    TH2F**                fHistoNGoodESDTracksVsNGammaCandidates;               
    TH2F**                fHistoSPDClusterTrackletBackground;                   
    TH1F**                fHistoNV0Tracks;                                      
    TProfile**            fProfileEtaShift;                                     
    TProfile**            fProfileJetJetXSection;                               
    TH1F**                fHistoJetJetNTrials;                                  
    TH1F**                fHistoEventSphericity;                                
    TH2F**                fHistoEventSphericityvsNtracks;                       

    TH1F**                 fHistoPtJet;                                          // Histogram of Jet Pt
    TH1F**                 fHistoJetEta;                                         // Histogram of Jet Eta
    TH1F**                 fHistoJetPhi;                                         // Histogram of Jet Phi
    TH1F**                 fHistoJetArea;                                        // Histogram of Jet Area
    TH1F**                 fHistoNJets;                                          // Histogram of number of jets
    TH1F**                 fHistoEventwJets;                                     // Histogram of number of events with jets > 0
    TH1F**                 fHistoJetPi0PtRatio;                                  // Histogram of PtPi0/PtJet
    TH1F**                 fHistoDoubleCounting;                                 // Histogram if NM candidates are defined within multiple jets
    TH2F**                 fHistoJetMotherInvMassPt;                             // Histogram of NM candidates with a jet in the event
    TH2F**                 fHistoPi0InJetMotherInvMassPt;                        // Histogram of NM candidates that are inside a jet
    TH2F**                 fHistoMotherBackJetInvMassPt;                         // Histogram of Backgrouns candidates that are involved with jets
    TH2F**                 fHistoRJetPi0Cand;                                    // Histogram of RJetPi0Cand vs Pt
    TH2F**                 fHistoEtaPhiJetPi0Cand;                               // Histogram of delta eta and delta phi distr between jet and NM candidates
    TH2F**                 fHistoEtaPhiJetWithPi0Cand;                           // Histogram of delta eta and delta phi distr when pi0 is inside a jet
    TH2F**                 fHistoJetFragmFunc;                                   // Histogram to determine fragmentation function
    TH2F**                 fHistoTruevsRecJetPt;                                 // Histogram of true jet pt vs reconstructed jet pt
    TH2F**                 fHistoTruePi0JetMotherInvMassPt;                      // Histogram of true pi0s in an event with a jet
    TH2F**                 fHistoTruePi0InJetMotherInvMassPt;                    // Histogram of true pi0s in a jet
    TH2F**                 fHistoTruePrimaryPi0JetInvMassPt;                     // Histogram of true primary pi0s in an event with a jet
    TH2F**                 fHistoTruePrimaryPi0inJetInvMassPt;                   // Histogram of true primary pi0s in a jet
    TH1F**                 fHistoTrueDoubleCountingPi0Jet;                       // Histogram of when a true pi0 is defined to be in multiple jets
    TH2F**                 fHistoTrueEtaJetMotherInvMassPt;                      // Histogram of true etas in an event with a jet
    TH2F**                 fHistoTrueEtaInJetMotherInvMassPt;                    // Histogram of true etas in a jet
    TH2F**                 fHistoTruePrimaryEtaJetInvMassPt;                     // Histogram of true primary etas in an event with a jet
    TH2F**                 fHistoTruePrimaryEtainJetInvMassPt;                   // Histogram of true primary etas in a jet
    TH1F**                 fHistoTrueDoubleCountingEtaJet;                       // Histogram of when a true eta is defined to be in multiple jets
    TH2F**                 fHistoTruePi0JetFragmFunc;                            // Histogram to determine true pi0 fragmentation function
    TH2F**                 fHistoTrueEtaJetFragmFunc;                            // Histogram to determine true eta fragmentation function
    TH1F**                 fHistoMCPi0JetInAccPt;                                // Histogram with weighted pi0 in a jet event in acceptance, pT
    TH1F**                 fHistoMCPi0inJetInAccPt;                              // Histogram with weighted pi0 in a jet in acceptance, pT
    TH1F**                 fHistoMCEtaJetInAccPt;                                // Histogram with weighted eta in a jet event in acceptance, pT
    TH1F**                 fHistoMCEtainJetInAccPt;                              // Histogram with weighted eta in a jet in acceptance, pT
    TH2F**                 fHistoTrueSecondaryPi0FromK0sJetInvMassPt;            // Histogram with validated secondary mothers from K0s in an event with a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0FromK0sinJetInvMassPt;          // Histogram with validated secondary mothers from K0s in a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0FromLambdaJetInvMassPt;         // Histogram with validated secondary mothers from lambda in an event with a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0FromLambdainJetInvMassPt;       // Histogram with validated secondary mothers from lambda in a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0FromK0lJetInvMassPt;            // Histogram with validated secondary mothers from K0l in an event with a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0FromK0linJetInvMassPt;          // Histogram with validated secondary mothers from K0l in a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0InvJetMassPt;                   // Histogram with validated secondary mothers in an event with a jet, invMass, pt
    TH2F**                 fHistoTrueSecondaryPi0InvinJetMassPt;                 // Histogram with validated secondary mothers in a jet, invMass, pt

    vector<Double_t>      fVectorJetPt;                                         // Vector of JetPt
    vector<Double_t>      fVectorJetPx;                                         // Vector of JetPx
    vector<Double_t>      fVectorJetPy;                                         // Vector of JetPy
    vector<Double_t>      fVectorJetPz;                                         // Vector of JetPz
    vector<Double_t>      fVectorJetEta;                                        // Vector of JetEta
    vector<Double_t>      fVectorJetPhi;                                        // Vector of JetPhi
    vector<Double_t>      fVectorJetArea;                                       // Vector of JetArea
    vector<Double_t>      fTrueVectorJetPt;                                     // Vector of True JetPt
    vector<Double_t>      fTrueVectorJetPx;                                     // Vector of True JetPx
    vector<Double_t>      fTrueVectorJetPy;                                     // Vector of True JetPy
    vector<Double_t>      fTrueVectorJetPz;                                     // Vector of True JetPz
    vector<Double_t>      fTrueVectorJetEta;                                    // Vector of True JetEta
    vector<Double_t>      fTrueVectorJetPhi;                                    // Vector of True JetPhi

    // tree for identified particle properties
    TTree**               tTrueInvMassROpenABPtFlag;                            
    Float_t               fInvMass;                                             
    Float_t               fRconv;                                               
    Float_t               fOpenRPrim;                                           
    Float_t               fInvMassRTOF;                                         
    Float_t               fPt;                                                  
    UChar_t               iFlag;                                                

    // tree for alpha/opening angle studies
    TTree**               tSigInvMassPtAlphaTheta;                              
    TTree**               tBckInvMassPtAlphaTheta;                              
    Float_t               fInvMassTreeInvMass;
    Float_t               fInvMassTreePt;
    Float_t               fInvMassTreeAlpha;
    Float_t               fInvMassTreeTheta;
    Int_t                 fInvMassTreeMixPool;
    Float_t               fInvMassTreeZVertex;
    Float_t               fInvMassTreeEta;

    // tree for E/p studies
    TTree**               tClusterEOverP;                                       
    Float_t               fClusterE;                                            
    Float_t               fClusterM02;                                          
    Float_t               fClusterM20;                                          
    Float_t               fClusterEP;                                           
    Int_t                 fClusterLeadCellID;                                   
    Int_t                 fClusterClassification;                               
    Float_t               fDeltaEta;                                            
    Float_t               fDeltaPhi;                                            
    Float_t               fTrackPt;                                             
    Int_t                 fTrackPID_e;                                          
    Int_t                 fTrackPID_Pi;                                         
    Int_t                 fTrackPID_K;                                          
    Int_t                 fTrackPID_P;                                          
    Float_t               fClusterIsoSumClusterEt;                              
    Float_t               fClusterIsoSumTrackEt;                                

    //tree for Jet-pi0 correlation studies
    TTree**               tTreeJetPi0Correlations;
    Float_t               fJetPt;                                               
    Float_t               fTrueJetPt;                                           
    Float_t               fPi0Pt;                                               
    Float_t               fPi0InvMass;                                          

    // hists for nonlineartiy calibration
//    TH2F**                fHistoTruePi0NonLinearity;                            //! E_truth/E_rec vs E_rec for TruePi0s
//    TH2F**                fHistoTrueEtaNonLinearity;                            //! E_truth/E_rec vs E_rec for TrueEtas

    // additional variables
    Double_t              fEventPlaneAngle;                                     // EventPlaneAngle
    TRandom3              fRandom;                                              // random
    Int_t                 fnCuts;                                               // number of cuts to be analysed in parallel
    Int_t                 fiCut;                                                // current cut
    Int_t                 fIsHeavyIon;                                          // switch for pp = 0, PbPb = 1, pPb = 2
    Bool_t                fDoLightOutput;                                       // switch for running light output, kFALSE -> normal mode, kTRUE -> light mode
    Bool_t                fDoMesonAnalysis;                                     // flag for meson analysis
    Int_t                 fDoMesonQA;                                           // flag for meson QA
    Int_t                 fDoClusterQA;                                         // flag for cluster QA
    Bool_t                fIsFromDesiredHeader;                                 // flag for MC headers
    Bool_t                fIsOverlappingWithOtherHeader;                        // flag for particles in MC overlapping between headers
    Int_t                 fIsMC;                                                // flag for MC information
    Bool_t                fDoTHnSparse;                                         // flag for using THnSparses for background estimation
    Bool_t                fSetPlotHistsExtQA;                                   // flag for extended QA hists
    Bool_t                fDoSoftAnalysis;                                      // bool for Sphericity analysis without jets
    Double_t              fWeightJetJetMC;                                      // weight for Jet-Jet MC
    Bool_t                fDoInOutTimingCluster;                                // manual timing cut for cluster to combine cluster within timing cut and without
    Double_t              fMinTimingCluster;                                    // corresponding ranges, min
    Double_t              fMaxTimingCluster;                                    // corresponding ranges, max
    Bool_t                fEnableSortForClusMC;                                 // switch on sorting for MC labels in cluster
    Bool_t                fProduceCellIDPlots;                                  // switch to produce CellID plots for fDoClusterQA==2
    Bool_t                fProduceTreeEOverP;                                   // flag for producing tree for E/p studies
    TTree*                tBrokenFiles;                                         // tree for keeping track of broken files
    TObjString*           fFileNameBroken;                                      // string object for broken file name
    TTree*                tClusterQATree;                                       // tree for specific cluster QA
    TObjString*           fCloseHighPtClusters;                                 // file name to indicate clusters with high pT (>15 GeV/c) very close to each other (<17 mrad)

    Int_t                 fLocalDebugFlag;                                      // debug flag for local running, must be '0' for grid running
    Bool_t                fAllowOverlapHeaders;                                 // enable overlapping headers for cluster selection
    Int_t                 fNCurrentClusterBasic;                                // current number of cluster without minE
    Int_t                 fTrackMatcherRunningMode;                             // CaloTrackMatcher running mode
  private:
    AliAnalysisTaskGammaCaloIso(const AliAnalysisTaskGammaCaloIso&);                  // Prevent copy-construction
    AliAnalysisTaskGammaCaloIso &operator=(const AliAnalysisTaskGammaCaloIso&);       // Prevent assignment

    ClassDef(AliAnalysisTaskGammaCaloIso, 53);
};

#endif