AliAnalysisTaskGammaCaloMerged.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKGAMMACALOMERGED_cxx
#define ALIANLYSISTASKGAMMACALOMERGED_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 <vector>
#include <map>

class AliAnalysisTaskGammaCaloMerged : public AliAnalysisTaskSE {
  public:

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

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

    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();

    // MC functions
    void SetIsMC(Int_t isMC)                              { fIsMC                       = isMC                                                            ; }
    void SetSelectedMesonID(Int_t anaMeson)               { fSelectedMesonID            = anaMeson                                                        ; }

    void ProcessMCParticles();
    void ProcessAODMCParticles();
    // determine source according to pdg code of mother
    Int_t GetSourceClassification(Int_t daughter, Int_t pdgCode);

    void ProcessTrueClusterCandidates( AliAODConversionPhoton* TruePhotonCandidate, Float_t m02, AliAODConversionPhoton *TrueSubClusterCandidate1,
                                    AliAODConversionPhoton *TrueSubClusterCandidate2);
    void ProcessTrueClusterCandidatesAOD( AliAODConversionPhoton* TruePhotonCandidate, Float_t m02, AliAODConversionPhoton *TrueSubClusterCandidate1,
                                    AliAODConversionPhoton *TrueSubClusterCandidate2);
// //     void ProcessTrueMesonCandidates( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);

    // switches for additional analysis streams or outputs
    void SetLightOutput( Bool_t flag )                    { fDoLightOutput              = flag;}
    void SetDoMesonQA(Int_t flag)                         { fDoMesonQA                  = flag                                                            ; }
    void SetDoClusterQA(Int_t flag)                       { fDoClusterQA                = flag                                                            ; }
    void SetPlotHistsExtQA(Bool_t flag)                   { fSetPlotHistsExtQA          = flag                                                            ; }

      // 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 calo photons
    void SetCaloMergedCutList(Int_t nCuts, TList *CutArray){
                                                            fnCuts                      = nCuts                                                           ;
                                                            fClusterMergedCutArray      = CutArray                                                        ;
                                                          }

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

    Int_t GetSelectedMesonID()                              { return fSelectedMesonID                                                                     ; }

    // Additional functions for convenience
    void SetLogBinningXTH2(TH2* histoRebin);

    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 detailed printouts
    void SetEnableDetailedPrintout(Bool_t enablePO)         { fEnableDetailedPrintOut   = enablePO                                                        ; }

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

    // FUnction to enable very detailed M02 distribution
    void SetEnableDetailedM02Distribtuon(Bool_t enableDetM02) { fDoDetailedM02          = enableDetM02                                                    ; }

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

  protected:
    AliV0ReaderV1*          fV0Reader;                                          // basic photon Selection Task
    TString                 fV0ReaderName;
    TString                 fCorrTaskSetting;
    Bool_t                  fDoLightOutput;                                     // switch for running light output, kFALSE -> normal mode, kTRUE -> light mode
    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**                 fTrueList;                                          // Array of lists with histograms with MC validated reconstructed properties
    TList**                 fMCList;                                            // Array of lists with histograms with pure MC information
    TList**                 fHeaderNameList;                                    // Array of lists with header names for MC header selection
    TList*                  fOutputContainer;                                   // Output container
    Int_t                   fNClusterCandidates;                                
    Int_t                   fNClusterMergedCandidates;                          
    TList*                  fEventCutArray;                                     // List with Event Cuts
    AliConvEventCuts*       fEventCuts;                                         // EventCutObject
    TList*                  fClusterCutArray;                                   // List with Cluster Cuts
    TList*                  fClusterMergedCutArray;                             // List with Cluster Cuts for merged clusters
    TList*                  fMesonCutArray;                                     // List with Meson Cuts
    AliConversionMesonCuts* fMesonCuts;                                         // MesonCutObject

    //histograms for mesons reconstructed quantities
    TH2F**                  fHistoMotherInvMassPt;                              
    TH2F**                  fHistoMotherPtY;                                    
    TH2F**                  fHistoMotherPtAlpha;                                

    // histograms for rec photon clusters/pi0 candidate
    TH1F**                  fHistoClusGammaPt;                                  
    TH1F**                  fHistoClusGammaE;                                   
    TH1F**                  fHistoClusOverlapHeadersGammaPt;                    
    TH2F**                  fHistoClusNLMPt;                                    
    TH2F**                  fHistoClusMergedPtvsM02;                            
    TH2F**                  fHistoClusMergedPtvsM02Accepted;                    
    TH2F**                  fHistoClusMergedEvsM02Accepted;                     
    TH2F**                  fHistoClusNCellsPt;                                 
    TH2F**                  fHistoClusMergedNCellsPt;                           
    TH2F**                  fHistoClusMergedNParticlePt;                        
    TH2F**                  fHistoClusMergedNCellsAroundPt;                     
    TH2F**                  fHistoClusMergedNCellsAroundAndInPt;                
    TH2F**                  fHistoClusMergedEAroundE;                           

    //histograms for pure MC quantities
    TH1I**                  fHistoMCHeaders;                                    
    TH1F**                  fHistoMCPi0Pt;                                      
    TH1F**                  fHistoMCPi0WOWeightPt;                              
    TH1F**                  fHistoMCPi0WOEvtWeightPt;                           
    TH1F**                  fHistoMCEtaPt;                                      
    TH1F**                  fHistoMCEtaWOWeightPt;                              
    TH1F**                  fHistoMCEtaWOEvtWeightPt;                           
    TH1F**                  fHistoMCPi0DalitzPt;                                
    TH1F**                  fHistoMCPi0DalitzWOWeightPt;                        
    TH1F**                  fHistoMCPi0DalitzWOEvtWeightPt;                     
    TH1F**                  fHistoMCEtaDalitzPt;                                
    TH1F**                  fHistoMCEtaDalitzWOWeightPt;                        
    TH1F**                  fHistoMCEtaDalitzWOEvtWeightPt;                     
    TH1F**                  fHistoMCPi0InAccPt;                                 
    TH1F**                  fHistoMCEtaInAccPt;                                 
    TH1F**                  fHistoMCPi0WOEvtWeightInAccPt;                      
    TH1F**                  fHistoMCEtaWOEvtWeightInAccPt;                      
    TH1F**                  fHistoMCPi0DalitzInAccPt;                           
    TH1F**                  fHistoMCEtaDalitzInAccPt;                           
    TH1F**                  fHistoMCPi0DalitzWOEvtWeightInAccPt;                
    TH1F**                  fHistoMCEtaDalitzWOEvtWeightInAccPt;                

    TH2F**                  fHistoMCSecPi0PtvsSource;                           
    TH2F**                  fHistoMCSecPi0InAccPtvsSource;                      
    TH2F**                  fHistoMCPi0PtJetPt;                                 
    TH2F**                  fHistoMCEtaPtJetPt;                                 
    TH2F**                  fHistoMCPrimaryPtvsSource;                          
    TH2F**                  fHistoMCPrimaryYvsSource;                           
    TH1F**                  fHistoMCDecayGammaPt;                               
    TH1F**                  fHistoMCAllGammaPt;                                 

    // MC validated cluster histos
    TH2F**                  fHistoTrueClusMergedPtvsM02;                        
    TH2F**                  fHistoTrueClusPi0PtvsM02;                           
    TH2F**                  fHistoTrueClusPi0DalitzPtvsM02;                     
    TH2F**                  fHistoTrueClusPrimPi0PtvsM02;                       
    TH2F**                  fHistoTrueClusSecPi0PtvsM02;                        
    TH2F**                  fHistoTrueClusSecPi0FromK0sPtvsM02;                 
    TH2F**                  fHistoTrueClusSecPi0FromK0lPtvsM02;                 
    TH2F**                  fHistoTrueClusSecPi0FromLambdaPtvsM02;              
    TH2F**                  fHistoTrueClusEtaPtvsM02;                           
    TH2F**                  fHistoTrueClusEtaDalitzPtvsM02;                     
    TH2F**                  fHistoTrueClusMergedPureFromPi0PtvsM02;             
    TH2F**                  fHistoTrueClusMergedPureFromEtaPtvsM02;             
    TH2F**                  fHistoTrueClusMergedPartConvFromPi0PtvsM02;         
    TH2F**                  fHistoTrueClusMergedPartConvFromEtaPtvsM02;         
    TH2F**                  fHistoTrueClusGammaFromPi0PtvsM02;                  
    TH2F**                  fHistoTrueClusGammaFromEtaPtvsM02;                  
    TH2F**                  fHistoTrueClusElectronFromPi0PtvsM02;               
    TH2F**                  fHistoTrueClusElectronFromEtaPtvsM02;               
    TH2F**                  fHistoTrueSecPi0PtvsDiffReco;                       

    TH2F**                  fHistoTrueClusBGPtvsM02;                            
    TH2F**                  fHistoTrueClusGammaPtvsM02;                         
    TH2F**                  fHistoTrueClusGammaPartConvPtvsM02;                 
    TH2F**                  fHistoTrueClusElectronPtvsM02;                      
    TH2F**                  fHistoTrueClusElectronFromGammaPtvsM02;             
    TH2F**                  fHistoTrueClusMergedInvMassvsPt;                    
    TH2F**                  fHistoTrueClusPi0InvMassvsPt;                       
    TH2F**                  fHistoTrueClusPrimPi0InvMassvsPt;                   
    TH2F**                  fHistoTrueClusEtaInvMassvsPt;                       
    TH2F**                  fHistoTrueClusBGInvMassvsPt;                        
    TH2F**                  fHistoTrueClusGammaInvMassvsPt;                     
    TH2F**                  fHistoTrueClusElectronInvMassvsPt;                  
    TH2F**                  fHistoTrueClusBGPtvsSource;                         
    TH2F**                  fHistoTrueClusGammaPtvsSource;                      
    TH2F**                  fHistoTrueClusElectronPtvsSource;                   
//    TH2F**                  fHistoTrueClusElectronPtvsMotherID;                 //!
//    TH2F**                  fHistoTrueClusElectronPtvsTopMotherID;              //!
//    TH2F**                  fHistoTrueClusElectronPtvsConvPhotonTopMotherID;    //!
    TH1F**                  fHistoTrueMergedMissedPDG;                          

    // MC validated reconstructed quantities mesons
    TH2F**                  fHistoTruePi0PtY;                                   
    TH2F**                  fHistoTrueEtaPtY;                                   
    TH2F**                  fHistoTruePi0PtAlpha;                               
    TH2F**                  fHistoTrueEtaPtAlpha;                               
    TH2F**                  fHistoTrueClusGammaEM02;                            
    TH2F**                  fHistoTrueClusElectronEM02;                         
    TH2F**                  fHistoTrueClusPi0EM02;                              
    TH2F**                  fHistoTrueClusEtaEM02;                              

    TH2F**                  fHistoTruePrimaryPi0PureMergedMCPtResolPt;          
    TH2F**                  fHistoTruePrimaryPi0MergedPartConvMCPtResolPt;      
    TH2F**                  fHistoTruePrimaryPi01GammaMCPtResolPt;              
    TH2F**                  fHistoTruePrimaryPi01ElectronMCPtResolPt;           
    TH2F**                  fHistoTruePrimaryEtaMCPtResolPt;                    
    TH2F**                  fHistoTrueSecondaryPi0MCPtResolPt;                  

    // MC validated reconstructed quantities photons
    TH2F**                  fHistoDoubleCountTruePi0PtvsM02;                    
    TH1F**                  fHistoDoubleCountTrueSecPi0Pt;                      
    TH2F**                  fHistoDoubleCountTrueEtaPtvsM02;                    
    vector<Int_t>           fVectorDoubleCountTruePi0s;                         
    vector<Int_t>           fVectorDoubleCountTrueEtas;                         

    // event histograms
    TH1F**                  fHistoNEvents;                                      
    TH1F**                  fHistoNEventsWOWeight;                              
    TH1F**                  fHistoNGoodESDTracks;                               
    TH1F**                  fHistoVertexZ;                                      
    TH1F**                  fHistoNClusterCandidates;                           
    TH1F**                  fHistoNClusterMergedCandidates;                     
    TH2F**                  fHistoNGoodESDTracksVsNClusterCandidates;           
    TH2F**                  fHistoSPDClusterTrackletBackground;                 
    TH1F**                  fHistoNV0Tracks;                                    
    TProfile**              fProfileEtaShift;                                   
    TProfile**              fProfileJetJetXSection;                             
    TH1F**                  fHistoJetJetNTrials;                                

    // additional variables
    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
    Int_t                   fDoMesonQA;                                         // flag for meson QA
    Int_t                   fDoClusterQA;                                       // flag for cluster QA
    Bool_t                  fIsFromMBHeader;                                    // flag for MC headers
    Bool_t                  fIsOverlappingWithOtherHeader;                      // flag for particles in MC overlapping between headers
    Int_t                   fIsMC;                                              // flag for MC information
    Bool_t                  fSetPlotHistsExtQA;                                 // flag for extended QA hists
    Double_t                fWeightJetJetMC;                                    // weight for Jet-Jet MC
    Int_t                   fSelectedMesonID;                                   // switch for meson analysis
    Bool_t                  fEnableDetailedPrintOut;                            // switch on detailed print outs
    Bool_t                  fEnableSortForClusMC;                               // switch on sorting for MC labels in cluster
    TTree*                  tBrokenFiles;                                       // tree for keeping track of broken files
    TObjString*             fFileNameBroken;                                    // string object for broken file name
    Bool_t                  fDoDetailedM02;                                     // detailed M02 distribution
    Int_t                   fTrackMatcherRunningMode;                           // CaloTrackMatcher running mode

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

    ClassDef(AliAnalysisTaskGammaCaloMerged, 28);
};

#endif