AliAnalysisTaskOmegaToPiZeroGamma.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKOMEGATOPIZEROGAMMA_cxx
#define ALIANLYSISTASKOMEGATOPIZEROGAMMA_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 AliAnalysisTaskOmegaToPiZeroGamma : public AliAnalysisTaskSE {
  public:

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

    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 ProcessPhotonCandidates();
    void CalculateOmegaCandidates();
    
    // MC functions
    void SetIsMC                        ( Int_t isMC)                                       { fIsMC = isMC                              ;}
    void ProcessMCParticles             ();
    void ProcessAODMCParticles          ();
    void ProcessTruePhotonCandidates    ( AliAODConversionPhoton* TruePhotonCandidate);
    void ProcessTruePhotonCandidatesAOD ( AliAODConversionPhoton* TruePhotonCandidate);
    void ProcessTrueClusterCandidates   ( AliAODConversionPhoton* TruePhotonCandidate);
    void ProcessTrueClusterCandidatesAOD( AliAODConversionPhoton* TruePhotonCandidate);
    void RelabelAODPhotonCandidates     ( Bool_t mode);
    void ProcessTrueMesonCandidates     ( AliAODConversionMother *OmegaCandidate,
                                          AliAODConversionPhoton *TrueGammaCandidate0, 
                                          AliAODConversionPhoton *TrueGammaCandidate1, 
                                          AliAODConversionPhoton *TrueGammaCandidate2);
    void ProcessTrueMesonCandidatesAOD  ( AliAODConversionMother *OmegaCandidate,
                                          AliAODConversionPhoton *TrueGammaCandidate0,
                                          AliAODConversionPhoton *TrueGammaCandidate1,
                                          AliAODConversionPhoton *TrueGammaCandidate2);
    
    // switches for additional analysis streams or outputs
    void SetDoMesonQA                   ( Int_t flag )                                      { fDoMesonQA = flag                           ;}
    void SetDoPhotonQA                  ( Int_t flag )                                      { fDoPhotonQA = 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 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 cut lists for the neutral pion
    void SetNeutralPionCutList          ( Int_t nCuts,
                                          TList *CutArray)                                  {
                                                                                              fnCuts = nCuts                              ;
                                                                                              fNeutralPionCutArray = CutArray             ;
                                                                                            }

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

    // BG HandlerSettings
    void CalculateBackground            ();
    void SetMoveParticleAccordingToVertex       ( Bool_t flag )                             { fMoveParticleAccordingToVertex = flag       ;}
    void MoveParticleAccordingToVertex          ( AliAODConversionPhoton* particle, 
                                                  const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex);
    void MoveParticleAccordingToVertex          (AliAODConversionMother* 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;}

    // set reconstruction method
    void SetReconMethod                 (Int_t ReconMethod) { fReconMethod = ReconMethod;}

    // set flag for doing pi0-gamma angle cut
    void SetDoPiZeroGammaAngleCut         (Bool_t DoPiZeroGammaAngleCut){ fDoPiZeroGammaAngleCut = DoPiZeroGammaAngleCut;}

    // set scaling factors for pi0-gamma angle cut
    void SetlowerFactor                  (Double_t lowerFactor){ flowerFactor = lowerFactor;}
    void SetupperFactor                  (Double_t upperFactor){ fupperFactor = upperFactor;}
    
  protected:
    AliV0ReaderV1*                      fV0Reader;              // basic photon Selection Task
    TString                             fV0ReaderName;
    AliGammaConversionAODBGHandler**    fBGHandler;             // BG handler for Conversion 
    AliGammaConversionAODBGHandler**    fBGClusHandler;         // BG handler for Cluster
    AliGammaConversionAODBGHandler**    fBGPi0Handler;          // BG handler for pi0's
    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**                             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*                              fPi0Candidates;         
    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*                              fNeutralPionCutArray;   // List with neutral pion cuts
    TList*                              fMesonCutArray;         // List with meson cuts

    //histograms for Conversions reconstructed quantities
    TH1F**                  fHistoConvGammaPt;                  
    TH1F**                  fHistoConvGammaR;                   
    TH1F**                  fHistoConvGammaEta;                 
                      // 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

    //histograms for mesons reconstructed quantities
    TH2F**                  fHistoPhotonPairInvMassPt;              
    TH2F**                  fHistoPhotonPairMatchedInvMassPt;       
    TH2F**                  fHistoPhotonPairYPt;                
    TH2F**                  fHistoPhotonPairAlphaPt;            
    TH2F**                  fHistoPhotonPairOpenAnglePt;        
    TH2F**                  fHistoPhotonPairEtaPhi;             
    TH2F**                  fHistoMotherConvPhotonEtaPhi;       
    TH2F**                  fHistoMotherInvMassPt;              
    TH2F**                  fHistoMotherMatchedInvMassPt;           
    TH2F**                  fHistoMotherAngleCutRejectedInvMassPt;  
    TH2F**                  fHistoMotherYPt;                    
    TH2F**                  fHistoMotherAlphaPt;                
    TH2F**                  fHistoMotherEtaPhi;                 
    TH2F**                  fHistoMotherPi0AnglePt;             
    TH2F**                  fHistoMotherGammaAnglePt;           
    TH2F**                  fHistoPi0GammaAnglePt;              
    TH1F**                  fHistoGammaFromMotherPt;            

    // BG histograms
    TH2F**                  fHistoDiffPi0SameGammaBackInvMassPt;
    TH2F**                  fHistoSamePi0DiffGammaBackInvMassPt;

    // histograms for rec photon clusters
    TH1F**                  fHistoClusGammaPt;                  
    TH1F**                  fHistoClusOverlapHeadersGammaPt;    
                    
    //histograms for pure MC quantities
    TH1F**                  fHistoMCAllGammaPt;                 
    TH1F**                  fHistoMCAllGammaEMCALAccPt;         
    TH1F**                  fHistoMCConvGammaPt;                
    TH1F**                  fHistoMCConvGammaR;                 
    TH1F**                  fHistoMCConvGammaEta;               
    TH1F**                  fHistoMCPi0Pt;                      
    TH1F**                  fHistoMCPi0WOWeightPt;              
    TH1F**                  fHistoMCPi0WOEvtWeightPt;           
    TH1F**                  fHistoMCPi0InAccPt;                 
    TH1F**                  fHistoMCPi0WOWeightInAccPt;         
    TH2F**                  fHistoMCPi0PtY;                     
    TH2F**                  fHistoMCPi0PtAlpha;                 
    TH2F**                  fHistoMCPi0PtJetPt;                 
    TH1F**                  fHistoMCGammaFromAllOmegaPt;        
    TH1F**                  fHistoMCGammaFromOmegaInAccPt;      
    TH2F**                  fHistoMCPi0FromAllOmegaInvMassPt;   
    TH2F**                  fHistoMCOmegaInAccInvMassPt;        
    TH2F**                  fHistoMCOmegaInvMassPt;             
    TH2F**                  fHistoMCAllOmegaYPt;                
    TH2F**                  fHistoMCOmegaInAccYPt;              
    TH2F**                  fHistoMCAllOmegaAlphaPt;            
    TH2F**                  fHistoMCOmegaInAccAlphaPt;          
    TH2F**                  fHistoMCPi0FromAllOmegaAlphaPt;     
    TH2F**                  fHistoMCPi0FromOmegaInAccAlphaPt;   
    TH2F**                  fHistoMCPi0FromAllOmegaYPt;         
    TH2F**                  fHistoMCPi0FromOmegaInAccYPt;       
    TH2F**                  fHistoMCPi0FromOmegaInAccInvMassPt; 
    TH2F**                  fHistoMCPi0FromAllOmegaEtaPhi;      
    TH2F**                  fHistoMCPi0FromOmegaInAccEtaPhi;    
    TH2F**                  fHistoMCAllOmegaEtaPhi;             
    TH2F**                  fHistoMCOmegaInAccEtaPhi;           
    TH2F**                  fHistoMCAllOmegaPiZeroAnglePt;      
    TH2F**                  fHistoMCAllPiZeroGammaAnglePt;      
    TH2F**                  fHistoMCAllOmegaGammaAnglePt;       
    TH2F**                  fHistoMCInAccOmegaPiZeroAnglePt;    
    TH2F**                  fHistoMCInAccPiZeroGammaAnglePt;    
    TH2F**                  fHistoMCInAccOmegaGammaAnglePt;     
    TH2F**                  fHistoMCAllOmegaInvMassPt;          
    TH2F**                  fHistoMCAllOmegaPtPi0Pt;            
    TH2F**                  fHistoMCInAccOmegaPtPi0Pt;          
    TH2F**                  fHistoMCAllOmegaPtGammaPt;          
    TH2F**                  fHistoMCInAccOmegaPtGammaPt;        

    // MC validated reconstructed quantities mesons
    TH2F**                  fHistoTrueOmegaInvMassPt;                           
    TH2F**                  fHistoTrueOmegaYPt;                                 
    TH2F**                  fHistoTrueOmegaAlphaPt;                             
    TH2F**                  fHistoTruePi0FromOmegaYPt;                          
    TH2F**                  fHistoTruePi0FromOmegaInvMassPt;                    
    TH2F**                  fHistoTruePi0FromOmegaAlphaPt;                      
    TH2F**                  fHistoTruePi0FromOmegaEtaPhi;                       
    TH2F**                  fHistoTruePi0FromOmegaOpenAnglePt;                  
    TH2F**                  fHistoTrueOmegaPi0AnglePt;                          
    TH2F**                  fHistoTrueOmegaGammaAnglePt;                        
    TH2F**                  fHistoTruePi0GammaAnglePt;                          
    TH2F**                  fHistoTrueOmegaEtaPhi;                              
    TH2F**                  fHistoTrueOmegaPtPi0Pt;                             
    TH2F**                  fHistoTrueOmegaPtGammaPt;                           
    TH1F**                  fHistoTrueGammaFromOmegaPt;                         

    vector<Int_t>           fVectorRecTruePi0s;                                 
    vector<Int_t>           fVectorDoubleCountTruePi0s;                         
    TH1F**                  fHistoMultipleCountTruePi0;                         
    map<Int_t,Int_t>        fMapMultipleCountTruePi0s;                          
    // event histograms
    TH1F**                  fHistoNEvents;                                      
    TH1F**                  fHistoNEventsMinGamma;                              
    TH1F**                  fHistoMCOmegaDecayChannels;                         
    TH1F**                  fHistoNEventsWOWeight;                              
    TH1F**                  fHistoNGoodESDTracks;                               
    TH1F**                  fHistoVertexZ;                                      
    TH1F**                  fHistoNGammaCandidates;                             
    TH1F**                  fHistoNClusterCandidates;                           
    TH2F**                  fHistoNGoodESDTracksVsNGammaCandidates;             
    TH2F**                  fHistoSPDClusterTrackletBackground;                 
    TH1F**                  fHistoNV0Tracks;                                    
    TProfile**              fProfileEtaShift;                                   
    TProfile**              fProfileJetJetXSection;                             
    TH1F**                  fHistoJetJetNTrials;                                

    // additional variables
    Double_t                fEventPlaneAngle;                                   // EventPlaneAngle
    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
    Int_t                   fDoMesonQA;                                         // flag for meson QA
    Int_t                   fDoPhotonQA;                                        // flag for photon 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 
    Bool_t                  fEnableSortForClusMC;                               // switch on sorting for MC labels in cluster
    Int_t                   fReconMethod;                                       // switch for combining photons: PCM-cal,cal = 0; PCM-cal,PCM = 1; cal-cal,cal = 2;
                                                                                // cal-cal,PCM = 3; PCM-PCM,cal = 4; PCM-PCM,PCM = 5
    Double_t                flowerFactor;                                       // factor maxfit is multiplied by to get lower limit for pi0-gamma angle cut
    Double_t                fupperFactor;                                       // factor maxfit is multiplied by to get upper limit for pi0-gamma angle cut
    Double_t                fMinPi0Pt;                                          // Min Pi0 Pt cut in GeV
    TF1*                    fmaxfit;                                            // function describing location of max. points in the distribution of pi0-gamma angle vs. pT

    Bool_t                  fDoPiZeroGammaAngleCut;                             // flag for pi0-gamma angle cut

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

    ClassDef(AliAnalysisTaskOmegaToPiZeroGamma, 11);
};

#endif