AliAnalysisTaskGammaConvCaloIso.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKGAMMAConvCaloIso_cxx
#define ALIANLYSISTASKGAMMAConvCaloIso_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 "AliAnalysisManager.h"
#include "TProfile2D.h"
#include "TH3.h"
#include "TH3F.h"
#include "THnSparse.h"
#include <vector>
#include <map>

class AliAnalysisTaskGammaConvCaloIso : public AliAnalysisTaskSE {
  public:

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

    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;
    }
    // Function to set correction task setting
    void SetCorrectionTaskSetting(TString setting) {fCorrTaskSetting = setting;}

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

    // MC functions
    void SetIsMC                        ( Int_t isMC)                                       { fIsMC = isMC                              ;}
    void ProcessMCParticles             ();
    void ProcessAODMCParticles          ();
    void RelabelAODPhotonCandidates     ( Bool_t mode);
    void ProcessTruePhotonCandidates    ( AliAODConversionPhoton* TruePhotonCandidate);
    void ProcessTrueClusterCandidates   ( AliAODConversionPhoton* TruePhotonCandidate,
                                          Float_t clusM02);
    void ProcessTrueClusterCandidatesAOD( AliAODConversionPhoton* TruePhotonCandidate,
                                          Float_t clusM02);
    void ProcessTruePhotonCandidatesAOD ( AliAODConversionPhoton* TruePhotonCandidate);
    void ProcessTrueMesonCandidates     ( AliAODConversionMother *Pi0Candidate,
                                          AliAODConversionPhoton *TrueGammaCandidate0,
                                          AliAODConversionPhoton *TrueGammaCandidate1,
                                          Bool_t matched);
    void ProcessTrueMesonCandidatesAOD  ( AliAODConversionMother *Pi0Candidate,
                                          AliAODConversionPhoton *TrueGammaCandidate0,
                                          AliAODConversionPhoton *TrueGammaCandidate1,
                                          Bool_t matched);
    void ProcessConversionPhotonsForMissingTags     ();
    void ProcessConversionPhotonsForMissingTagsAOD  ();
    void ProcessMCParticlesIsolation(AliVCluster *cluster, AliAODConversionPhoton *photoncandidate);


    // switches for additional analysis streams or outputs
    void SetDoPrimaryTrackMatching      ( Bool_t flag )                                     { fDoPrimaryTrackMatching = flag              ;}
    void SetLightOutput                 ( Bool_t flag )                                     { fDoLightOutput = flag                       ;}
    void SetDoMesonAnalysis             ( Bool_t flag )                                     { fDoMesonAnalysis = flag                     ;}
    void SetDoMesonQA                   ( Int_t flag )                                      { fDoMesonQA = flag                           ;}
    void SetDoPhotonQA                  ( Int_t flag )                                      { fDoPhotonQA = flag                          ;}
    void SetDoClusterQA                 ( Int_t flag )                                      { fDoClusterQA = flag                         ;}
    void SetUseTHnSparse                ( Bool_t flag )                                     { fDoTHnSparse = flag                         ;}
    void SetPlotHistsExtQA              ( Bool_t flag )                                     { fSetPlotHistsExtQA = flag                   ;}
    void SetDoTreeConvGammaShowerShape  ( Bool_t flag )                                     { fDoConvGammaShowerShapeTree = flag          ;}
    void SetDoTreeInvMassShowerShape    ( Bool_t flag )                                     { fDoInvMassShowerShapeTree = flag            ;}
    void SetAllowOverlapHeaders         ( Bool_t allowOverlapHeader )                       { fAllowOverlapHeaders = allowOverlapHeader   ;}

    // 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 conversion photons
    void SetConversionCutList           ( Int_t nCuts,
                                          TList *CutArray)                                  {
                                                                                              fnCuts = nCuts                              ;
                                                                                              fCutArray = 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 SetMoveParticleAccordingToVertex       ( Bool_t flag )                             { fMoveParticleAccordingToVertex = flag       ;}
    void FillPhotonCombinatorialBackgroundHist  ( AliAODConversionPhoton *TruePhotonCandidate,
                                                  Int_t pdgCode[] );
    void MoveParticleAccordingToVertex          ( AliAODConversionPhoton* particle,
                                                  const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex);
    void UpdateEventByEventData         ();

    // Additional functions for convenience
    void SetLogBinningXTH2              ( TH2* histoRebin );
    Int_t GetSourceClassification       (Int_t daughter,
                                         Int_t pdgCode );
    Bool_t CheckVectorOnly              ( vector<Int_t> &vec,
                                          Int_t tobechecked );
    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 );

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

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


  protected:
    AliV0ReaderV1*                      fV0Reader;              // basic photon Selection Task
    TString                             fV0ReaderName;
    TString                             fCorrTaskSetting;       // Correction Task Special Name
    AliGammaConversionAODBGHandler**    fBGHandler;             // BG handler for Conversion
    AliConversionAODBGHandlerRP**       fBGHandlerRP;           // BG handler for Conversion (possibility to mix with respect to RP)
    AliGammaConversionAODBGHandler**    fBGClusHandler;         // BG handler for Cluster
    AliConversionAODBGHandlerRP**       fBGClusHandlerRP;       // BG handler for Cluster (possibility to mix with respect to RP)
    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**                             fPhotonDCAList;         // Array of lists with photon dca trees
    TList**                             fGammaERM02;            // Array of lists with conv photon shower shape trees
    TList**                             fInvMassShowerShape;    // Array of lists with invMass shower shape trees
    TList**                             fTrueList;              // Array of lists with histograms with MC validated reconstructed properties
    TList**                             fMCList;                // Array of lists with histograms with pure MC information
    TList**                             fClusterOutputList;     
    TList*                              fOutputContainer;       // Output container
    TClonesArray*                       fReaderGammas;          // Array with conversion photons selected by V0Reader Cut
    TList*                              fGammaCandidates;       // current list of photon candidates
    TList*                              fClusterCandidates;     
    TList*                              fIsoCandidates;         // current list of isolated cluster candidates
    TList*                              fEventCutArray;         // List with Event Cuts
    AliConvEventCuts*                   fEventCuts;             // EventCutObject
    TList*                              fCutArray;              // List with Conversion Cuts
    AliConversionPhotonCuts*            fConversionCuts;        // ConversionCutObject
    TList*                              fClusterCutArray;       // List with Cluster Cuts
    AliCaloPhotonCuts*                  fCaloPhotonCuts;        // CaloPhotonCutObject
    TList*                              fMesonCutArray;         // List with Meson Cuts
    AliConversionMesonCuts*             fMesonCuts;             // MesonCutObject

    //histograms for Conversions reconstructed quantities
    TH1F**                  fHistoConvGammaPt;                  
    TTree**                 fTreeConvGammaPtDcazCat;            
    UShort_t                fPtGamma;                           
    Short_t                 fDCAzPhoton;                        
    UChar_t                 fCharCatPhoton;                     
    UChar_t                 fCharPhotonMCInfo;                  
                      // 0: garbage,
                      // 1: background
                      // 2: secondary photon not from eta or k0s,
                      // 3: secondary photon from eta,
                      // 4: secondary photon from k0s,
                      // 5: dalitz
                      // 6: primary gamma
    TTree**                 tESDGammaERM02;                     
    Float_t                 tESDClusE;                          
    Float_t                 tESDGammaConvR;                     
    Float_t                 tESDClusterM02;                     
    Float_t                 tESDClusterM20;                     
    Float_t                 tESDClusterEta;                     
    Float_t                 tESDClusterPhi;                     
    Float_t                 tESDClusterNCells;                  
    Float_t                 tESDClusterMaxECell;                
    Float_t                 tESDClusterNLM;                     

    TTree**                 tESDInvMassShowerShape;             
    Float_t                 tESDIMMesonInvMass;                 
    Float_t                 tESDIMMesonPt;                      
    Float_t                 tESDIMClusE;                        
    Float_t                 tESDIMClusterM02;                   
    Float_t                 tESDIMClusterM20;                   
    Int_t                   tESDIMClusterLeadCellID;            
    Int_t                   tESDIMClusterClassification;        
    Float_t                 tESDIMClusMatchedTrackPt;           
    Float_t                 tESDIMClusTrackDeltaEta;            
    Float_t                 tESDIMClusTrackDeltaPhi;            
    Float_t                 tESDIMClusterIsoSumClusterEt;       
    Float_t                 tESDIMClusterIsoSumTrackEt;         
    map<Long_t,Int_t>       tESDmapIsClusterAcceptedWithoutTrackMatch; 

    //histograms for mesons reconstructed quantities
    TH2F**                  fHistoMotherInvMassPt;              
    TH2F**                  fHistoMotherInvMassIsoPt;           
    TH2F**                  fHistoMotherMatchedInvMassPt;       
    THnSparseF**            fSparseMotherInvMassPtZM;           
    TH2F**                  fHistoMotherBackInvMassPt;          
    TH2F**                  fHistoMotherBackInvMassIsoPt;       
    THnSparseF**            fSparseMotherBackInvMassPtZM;       
    TH2F**                  fHistoMotherInvMassPtAlpha;         
    TH2F**                  fHistoMotherPi0PtY;                 
    TH2F**                  fHistoMotherEtaPtY;                 
    TH2F**                  fHistoMotherPi0PtAlpha;             
    TH2F**                  fHistoMotherEtaPtAlpha;             
    TH2F**                  fHistoMotherPi0PtOpenAngle;         
    TH2F**                  fHistoMotherEtaPtOpenAngle;         
    TH2F**                  fHistoMotherPi0ConvPhotonEtaPhi;    
    TH2F**                  fHistoMotherEtaConvPhotonEtaPhi;    
    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 photons tagged by Calo
    TH2F**                  fHistoPhotonPairPtconv;             
    TH2F**                  fHistoPhotonPairMixedEventPtconv;   
    // histograms for rec photon clusters
    TH1F**                  fHistoClusGammaPt;                  
    TH1F**                  fHistoClusGammaE;                   
    TH1F**                  fHistoClusOverlapHeadersGammaPt;    
    TH1F**                  fHistoClusAllHeadersGammaPt;        
    TH1F**                  fHistoClusRejectedHeadersGammaPt;   

    //histograms for pure MC quantities
    TH1I**                  fHistoMCHeaders;                    
    //histograms for pure MC quantities for gamma part
    TH1F**                  fHistoMCAllGammaPt;                 
    TH1F**                  fHistoMCAllGammaEMCALAccPt;         
    TH2F**                  fHistoMCAllSecondaryGammaPt;        
    TH1F**                  fHistoMCDecayGammaPi0Pt;            
    TH1F**                  fHistoMCDecayGammaRhoPt;            
    TH1F**                  fHistoMCDecayGammaEtaPt;            
    TH1F**                  fHistoMCDecayGammaOmegaPt;          
    TH1F**                  fHistoMCDecayGammaEtapPt;           
    TH1F**                  fHistoMCDecayGammaPhiPt;            
    TH1F**                  fHistoMCDecayGammaSigmaPt;          
    TH1F**                  fHistoMCConvGammaPt;                
    TH2F**                  fHistoMCSecondaryConvGammaPt;       

    //histograms for pure MC quantities for mesaon analysis
    TH1F**                  fHistoMCPi0Pt;                      
    TH1F**                  fHistoMCPi0WOWeightPt;              
    TH1F**                  fHistoMCPi0WOEvtWeightPt;           
    TH1F**                  fHistoMCEtaPt;                      
    TH1F**                  fHistoMCEtaWOWeightPt;              
    TH1F**                  fHistoMCEtaWOEvtWeightPt;           
    TH1F**                  fHistoMCPi0InAccPt;                 
    TH1F**                  fHistoMCPi0WOWeightInAccPt;         
    TH1F**                  fHistoMCPi0WOEvtWeightInAccPt;      
    TH1F**                  fHistoMCEtaInAccPt;                 
    TH1F**                  fHistoMCEtaWOWeightInAccPt;         
    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;                 

    // histograms for pure MC quantites for dir gamma analysis part
    TH2F**                  fHistoMCPi0PtGammaLeg;              
    TH2F**                  fHistoMCPi0WOWeightPtGammaLeg;      
    TH2F**                  fHistoMCPi0InAccPtGammaLeg;         
    TH2F**                  fHistoMCPi0WOWeightInAccPtGammaLeg; 
    TH2F**                  fHistoMCSecPi0PtGamma1vsSource;     
    TH2F**                  fHistoMCSecPi0InAccPtGamma1vsSource;
    TH2F**                  fHistoMCSecPi0PtGamma2vsSource;     
    TH2F**                  fHistoMCSecPi0InAccPtGamma2vsSource;

    // MC validated reconstructed quantities mesons
    TH2F**                  fHistoTruePi0InvMassPt;                             
    TH2F**                  fHistoTrueEtaInvMassPt;                             
    TH2F**                  fHistoTruePi0MatchedInvMassPt;                      
    TH2F**                  fHistoTrueEtaMatchedInvMassPt;                      
    TH2F**                  fHistoTruePi0CaloPhotonInvMassPt;                   
    TH2F**                  fHistoTrueEtaCaloPhotonInvMassPt;                   
    TH2F**                  fHistoTruePi0CaloConvertedPhotonInvMassPt;          
    TH2F**                  fHistoTruePi0CaloConvertedPhotonMatchedInvMassPt;   
    TH2F**                  fHistoTruePi0CaloConvPhotonConvRPt;                 
    TH2F**                  fHistoTruePi0CaloConvPhotonConvRAlpha;              
    TH2F**                  fHistoTruePi0CaloConvPhotonPtAlpha;                 
    TH2F**                  fHistoTrueEtaCaloConvertedPhotonInvMassPt;          
    TH2F**                  fHistoTrueEtaCaloConvertedPhotonMatchedInvMassPt;   
    TH2F**                  fHistoTrueEtaCaloConvPhotonConvRPt;                 
    TH2F**                  fHistoTrueEtaCaloConvPhotonConvRAlpha;              
    TH2F**                  fHistoTrueEtaCaloConvPhotonPtAlpha;                 
    TH2F**                  fHistoTruePi0CaloElectronInvMassPt;                 
    TH2F**                  fHistoTrueEtaCaloElectronInvMassPt;                 
    TH2F**                  fHistoTruePi0CaloMergedClusterInvMassPt;            
    TH2F**                  fHistoTrueEtaCaloMergedClusterInvMassPt;            
    TH2F**                  fHistoTrueMotherCaloEMNonLeadingInvMassPt;          
    TH2F**                  fHistoTruePi0CaloMergedClusterPartConvInvMassPt;    
    TH2F**                  fHistoTrueEtaCaloMergedClusterPartConvInvMassPt;    
    TH2F**                  fHistoTruePrimaryPi0InvMassPt;                      
    TH2F**                  fHistoTruePrimaryEtaInvMassPt;                      
    TH2F**                  fHistoTruePrimaryPi0W0WeightingInvMassPt;           
    TH2F**                  fHistoTruePrimaryEtaW0WeightingInvMassPt;           
    TProfile2D**            fProfileTruePrimaryPi0WeightsInvMassPt;             
    TProfile2D**            fProfileTruePrimaryEtaWeightsInvMassPt;             
    TH2F**                  fHistoTruePrimaryPi0MCPtResolPt;                    
    TH2F**                  fHistoTruePrimaryEtaMCPtResolPt;                    
    TH2F**                  fHistoTrueMotherPi0ConvPhotonEtaPhi;                
    TH2F**                  fHistoTrueMotherEtaConvPhotonEtaPhi;                
    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
    TH1F**                  fHistoTrueConvGammaPt;                              
    TH2F**                  fHistoCombinatorialPt;                              
    TH1F**                  fHistoTruePrimaryConvGammaPt;                       
    TH2F**                  fHistoTruePrimaryConvGammaESDPtMCPt;                
    TH2F**                  fHistoTrueSecondaryConvGammaPt;                     
    TH2F**                  fHistoTrueSecondaryConvGammaMCPt;                   
    TH2F**                  fHistoTrueSecondaryConvGammaFromXFromK0sMCPtESDPt;  
    TH2F**                  fHistoTrueSecondaryConvGammaFromXFromK0lMCPtESDPt;  
    TH2F**                  fHistoTrueSecondaryConvGammaFromXFromLambdaMCPtESDPt; 

    TH1F**                  fHistoTrueClusGammaPt;                              
    TH1F**                  fHistoTrueClusElectronPt;                           
    TH1F**                  fHistoTrueClusConvGammaPt;                          
    TH1F**                  fHistoTrueClusConvGammaFullyPt;                     
    TH1F**                  fHistoTrueClusMergedGammaPt;                        
    TH1F**                  fHistoTrueClusMergedPartConvGammaPt;                
    TH1F**                  fHistoTrueClusDalitzPt;                             
    TH1F**                  fHistoTrueClusDalitzMergedPt;                       
    TH1F**                  fHistoTrueClusPhotonFromElecMotherPt;               
    TH1F**                  fHistoTrueClusShowerPt;                             
    TH1F**                  fHistoTrueClusSubLeadingPt;                         
    TH1F**                  fHistoTrueClusNMothers;                             
    TH1F**                  fHistoTrueClusEMNonLeadingPt;                       
    TH2F**                  fHistoTrueNLabelsInClusPt;                          
    TH1F**                  fHistoTruePrimaryClusGammaPt;                       
    TH2F**                  fHistoTruePrimaryClusGammaESDPtMCPt;                
    TH1F**                  fHistoTruePrimaryClusConvGammaPt;                   
    TH2F**                  fHistoTruePrimaryClusConvGammaESDPtMCPt;            
    TH1F**                  fHistoTrueSecondaryClusGammaPt;                     
    TH1F**                  fHistoTrueSecondaryClusGammaFromK0sPt;              
    TH1F**                  fHistoTrueSecondaryClusGammaFromK0lPt;              
    TH1F**                  fHistoTrueSecondaryClusGammaFromLambdaPt;           

    // MC validated reconstructed quantities for direct photon reco
    TH2F**                  fHistoTruePrimaryPi0PhotonPairPtconv;               
    TH2F**                  fHistoTruePrimaryPi0W0WeightsPhotonPairPtconv;      
    TH1F**                  fHistoTruePrimaryPi0DCPtconv;                       
    TH1F**                  fHistoTruePrimaryPi0MissingPtconv;                  
    TH2F**                  fHistoTrueSecondaryPi0PhotonPairPtconv;             
    TH2F**                  fHistoTrueSecondaryPi0FromK0sPhotonPairPtconv;      
    TH2F**                  fHistoTrueSecondaryPi0FromK0lPhotonPairPtconv;      
    TH2F**                  fHistoTrueSecondaryPi0FromLambdaPhotonPairPtconv;   
    TH2F**                  fHistoTrueSecondaryPi0DCPtconvSource;               
    TH2F**                  fHistoTrueSecondaryPi0MissingPtconvSource;          

    // variable to keep track of multiple & missing reco
    vector<Int_t>           fVectorRecTruePi0s;                                 
    vector<Int_t>           fVectorRecTrueEtas;                                 
    TH2F**                  fHistoDoubleCountTruePi0InvMassPt;                  
    TH2F**                  fHistoDoubleCountTrueEtaInvMassPt;                  
    TH2F**                  fHistoDoubleCountTrueConvGammaRPt;                  
    TH2F**                  fHistoDoubleCountTrueClusterGammaPt;                
    vector<Int_t>           fVectorDoubleCountTruePi0s;                         
    vector<Int_t>           fVectorDoubleCountTrueEtas;                         
    vector<Int_t>           fVectorDoubleCountTrueConvGammas;                   
    vector<Int_t>           fVectorDoubleCountTrueClusterGammas;                
    TH1F**                  fHistoMultipleCountTruePi0;                         
    TH1F**                  fHistoMultipleCountTrueEta;                         
    TH1F**                  fHistoMultipleCountTrueConvGamma;                   
    TH1F**                  fHistoMultipleCountTrueClusterGamma;                
    map<Int_t,Int_t>        fMapMultipleCountTruePi0s;                          
    map<Int_t,Int_t>        fMapMultipleCountTrueEtas;                          
    map<Int_t,Int_t>        fMapMultipleCountTrueConvGammas;                    
    map<Int_t,Int_t>        fMapMultipleCountTrueClusterGammas;                 

    // further QA and calibration hist for Calo clusters
    TH2F**                  fHistoTrueClusGammaEM02;                            
    TH2F**                  fHistoTrueClusPi0EM02;                              
    TH2F**                  fHistoTruePi0InvMassECalib;                         
    TH2F**                  fHistoTruePi0PureGammaInvMassECalib;                

    // event histograms
    TH1F**                  fHistoNEvents;                                      
    TH1F**                  fHistoNEventsWOWeight;                              
    TH1F**                  fHistoNGoodESDTracks;                               
    TH1F**                  fHistoVertexZ;                                      
    TH1F**                  fHistoVertexX;                                      
    TH1F**                  fHistoVertexY;                                      
    TH1F**                  fHistoNGammaCandidates;                             
    TH2F**                  fHistoNGoodESDTracksVsNGammaCandidates;             
    TH2F**                  fHistoSPDClusterTrackletBackground;                 
    TH1F**                  fHistoNV0Tracks;                                    
    TProfile**              fProfileEtaShift;                                   
    TProfile**              fProfileJetJetXSection;                             
    TH1F**                  fHistoJetJetNTrials;                                

    // 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                   fNGammaCandidates;                                  // number of gamma candidates in event
    Double_t*               fUnsmearedPx;                                       //[fNGammaCandidates]
    Double_t*               fUnsmearedPy;                                       //[fNGammaCandidates]
    Double_t*               fUnsmearedPz;                                       //[fNGammaCandidates]
    Double_t*               fUnsmearedE;                                        //[fNGammaCandidates]
    Int_t*                  fMCEventPos;                                        //[fNGammaCandidates]
    Int_t*                  fMCEventNeg;                                        //[fNGammaCandidates]
    Int_t*                  fESDArrayPos;                                       //[fNGammaCandidates]
    Int_t*                  fESDArrayNeg;                                       //[fNGammaCandidates]
    Int_t                   fnCuts;                                             // number of cuts to be analysed in parallel
    Int_t                   fiCut;                                              // current cut
    Bool_t                  fMoveParticleAccordingToVertex;                     // boolean for BG calculation
    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                   fDoPhotonQA;                                        // flag for photon 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
    Double_t                fWeightJetJetMC;                                    // weight for Jet-Jet MC
    Bool_t                  fDoConvGammaShowerShapeTree;                        // flag for tree with conv gamma R vs energy vs shower shape
    Bool_t                  fEnableSortForClusMC;                               // switch on sorting for MC labels in cluster
    Bool_t                  fDoPrimaryTrackMatching;                            // switch for basic track matching for primaries
    Bool_t                  fDoInvMassShowerShapeTree;                          // flag for producing tree tESDInvMassShowerShape
    TTree*                  tBrokenFiles;                                       // tree for keeping track of broken files
    TObjString*             fFileNameBroken;                                    // string object for broken file name
    Bool_t                  fAllowOverlapHeaders;                               // enable overlapping headers for cluster selection
    Int_t                   fTrackMatcherRunningMode;                           // CaloTrackMatcher running mode


  private:
    AliAnalysisTaskGammaConvCaloIso(const AliAnalysisTaskGammaConvCaloIso&); // Prevent copy-construction
    AliAnalysisTaskGammaConvCaloIso &operator=(const AliAnalysisTaskGammaConvCaloIso&); // Prevent assignment

    ClassDef(AliAnalysisTaskGammaConvCaloIso, 1);
};

#endif