AliAnalysisTaskHeavyNeutralMesonToGG.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKHEAVYNEUTRALMESONTOGG_H
#define ALIANALYSISTASKHEAVYNEUTRALMESONTOGG_H

#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 AliAnalysisTaskHeavyNeutralMesonToGG : public AliAnalysisTaskSE {
public:

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

  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;}
  void SetDoClusterSelectionForTriggerNorm(Bool_t flag)         { fEnableClusterCutsForTrigger= flag    ;}

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

  // 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 ProcessTrueMesonCandidatesConvCalo     ( AliAODConversionMother *Pi0Candidate,
                                                AliAODConversionPhoton *TrueGammaCandidate0,
                                                AliAODConversionPhoton *TrueGammaCandidate1,
                                                Bool_t matched);
  void ProcessTrueMesonCandidatesConvCaloAOD  ( AliAODConversionMother *Pi0Candidate,
                                                AliAODConversionPhoton *TrueGammaCandidate0,
                                                AliAODConversionPhoton *TrueGammaCandidate1,
                                                Bool_t matched);
  void ProcessTrueMesonCandidatesCalo     ( AliAODConversionMother *Pi0Candidate,
                                            AliAODConversionPhoton *TrueGammaCandidate0,
                                            AliAODConversionPhoton *TrueGammaCandidate1 );
  void ProcessTrueMesonCandidatesCaloAOD  ( AliAODConversionMother *Pi0Candidate,
                                            AliAODConversionPhoton *TrueGammaCandidate0,
                                            AliAODConversionPhoton *TrueGammaCandidate1 );
  void ProcessTrueMesonCandidatesConv     ( AliAODConversionMother *Pi0Candidate,
                                            AliAODConversionPhoton *TrueGammaCandidate0,
                                            AliAODConversionPhoton *TrueGammaCandidate1 );
  void ProcessTrueMesonCandidatesConvAOD  ( AliAODConversionMother *Pi0Candidate,
                                            AliAODConversionPhoton *TrueGammaCandidate0,
                                            AliAODConversionPhoton *TrueGammaCandidate1 );

  // switches for additional analysis streams or outputs
  void SetDoPrimaryTrackMatching      ( Bool_t flag )                                     { fDoPrimaryTrackMatching = flag              ;}
  void SetLightOutput                 ( Bool_t flag )                                     { fDoLightOutput = flag                       ;}
  void SetMesonRecoMode               ( Int_t flag )                                      { fMesonRecoMode = flag                       ;}
  void SetMesonType                   ( Int_t flag )                                      { fMesonType = 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 CalculateBackgroundRP          ();
  void RotateParticle                 ( AliAODConversionPhoton *gamma );
  void RotateParticleAccordingToEP    ( AliAODConversionPhoton *gamma,
                                        Double_t previousEventEP,
                                        Double_t thisEventEP );
  void SetMoveParticleAccordingToVertex       ( Bool_t flag )                             { fMoveParticleAccordingToVertex = flag       ;}
  void MoveParticleAccordingToVertex          ( AliAODConversionPhoton* particle,
                                                const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex);
  void UpdateEventByEventData         ();

  // Additional functions for convenience
  void SetLogBinningXTH2              ( TH2* histoRebin );
  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;}


protected:
  TRandom3                            fRandom;                                // random number
  AliV0ReaderV1*                      fV0Reader;                              // basic photon Selection Task
  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
  AliConvEventCuts*                   fEventCuts;                             // EventCutObject
  AliConversionPhotonCuts*            fConversionCuts;                        // ConversionCutObject
  AliCaloPhotonCuts*                  fCaloPhotonCuts;                        // CaloPhotonCutObject
  AliConversionMesonCuts*             fMesonCuts;                             // MesonCutObject

  TList**                             fCutFolder;                             // Array of lists for containers belonging to cut
  TList**                             fESDList;                               // Array of lists with histograms with reconstructed properties
  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*                              fOutputContainer;                       // Output container
  TList*                              fGammaCandidates;                       
  TList*                              fClusterCandidates;                     
  TList*                              fEventCutArray;                         // List with Event Cuts
  TList*                              fCutArray;                              // List with Conversion Cuts
  TList*                              fClusterCutArray;                       // List with Cluster Cuts
  TList*                              fMesonCutArray;                         // List with Meson Cuts
  TClonesArray*                       fReaderGammas;                          // Array with conversion photons selected by V0Reader Cut

  TString                             fV0ReaderName;                          // V0Reader name to be found in input
  TString                             fCorrTaskSetting;                       // Correction Task Special Name

  TObjString*             fFileNameBroken;                                    // string object for broken file name

  THnSparseF**            fSparseMotherInvMassPtZM;                           
  THnSparseF**            fSparseMotherBackInvMassPtZM;                       

  TTree*                  fTreeBrokenFiles;                                   // tree for keeping track of broken files

  TProfile2D**            fProfileTruePrimaryMesonWeightsInvMassPt;           

  TH2F**                  fHistoMotherInvMassPt;                              
  TH2F**                  fHistoMotherMatchedInvMassPt;                       
  TH2F**                  fHistoMotherBackInvMassPt;                          
  TH2F**                  fHistoMotherMesonPtY;                               
  TH2F**                  fHistoMotherMesonPtAlpha;                           
  TH2F**                  fHistoMotherMesonPtOpenAngle;                       
  TH2F**                  fHistoMotherMesonConvPhotonEtaPhi;                  
  TH2F**                  fHistoTrueMesonInvMassPt;                           
  TH2F**                  fHistoTrueMesonMatchedInvMassPt;                    
  TH2F**                  fHistoTrueMesonCaloPhotonInvMassPt;                 
  TH2F**                  fHistoTrueMesonCaloConvertedPhotonInvMassPt;        
  TH2F**                  fHistoTrueMesonCaloMixedPhotonConvPhotonInvMassPt;  
  TH2F**                  fHistoTrueMesonCaloConvertedPhotonMatchedInvMassPt; 
  TH2F**                  fHistoTrueMesonCaloElectronInvMassPt;               
  TH2F**                  fHistoTrueMesonCaloMergedClusterInvMassPt;          
  TH2F**                  fHistoTrueMesonCaloMergedClusterPartConvInvMassPt;  
  TH2F**                  fHistoTruePrimaryMesonInvMassPt;                    
  TH2F**                  fHistoTruePrimaryMesonW0WeightingInvMassPt;         
  TH2F**                  fHistoTruePrimaryMesonMCPtResolPt;                  
  TH2F**                  fHistoTrueMotherMesonConvPhotonEtaPhi;              
  TH2F**                  fHistoTrueBckGGInvMassPt;                           
  TH2F**                  fHistoTrueBckFullMesonContainedInOneClusterInvMassPt; 
  TH2F**                  fHistoTrueBckAsymEClustersInvMassPt;                
  TH2F**                  fHistoTrueBckContInvMassPt;                         
  TH2F**                  fHistoTrueMesonPtY;                                 
  TH2F**                  fHistoTrueMesonPtAlpha;                             
  TH2F**                  fHistoTrueMesonPtOpenAngle;                         
  TH2F**                  fHistoMCMesonPtY;                                   
  TH2F**                  fHistoMCMesonPtAlpha;                               
  TH2F**                  fHistoMCMesonPtJetPt;                               
  TH2F**                  fHistoTrueNLabelsInClusPt;                          
  TH2F**                  fHistoDoubleCountTrueMesonInvMassPt;                
  TH2F**                  fHistoDoubleCountTrueConvGammaRPt;                  
  TH2F**                  fHistoDoubleCountTrueClusterGammaPt;                
  TH2F**                  fHistoSPDClusterTrackletBackground;                 

  TProfile**              fProfileEtaShift;                                   
  TProfile**              fProfileJetJetXSection;                             

  TH1I**                  fHistoMCHeaders;                                    

  TH1F**                  fHistoConvGammaPt;                                  
  TH1F**                  fHistoClusGammaPt;                                  
  TH1F**                  fHistoClusGammaE;                                   
  TH1F**                  fHistoClusOverlapHeadersGammaPt;                    
  TH1F**                  fHistoClusAllHeadersGammaPt;                        
  TH1F**                  fHistoClusRejectedHeadersGammaPt;                   
  TH1F**                  fHistoMotherInvMassRejected;                        
  TH1F**                  fHistoMCMesonPt;                                    
  TH1F**                  fHistoMCMesonWOWeightPt;                            
  TH1F**                  fHistoMCMesonWOEvtWeightPt;                         
  TH1F**                  fHistoMCMesonInAccPt;                               
  TH1F**                  fHistoMCMesonWOWeightInAccPt;                       
  TH1F**                  fHistoMCMesonWOEvtWeightInAccPt;                    
  TH1F**                  fHistoTrueConvGammaPt;                              
  TH1F**                  fHistoTruePrimaryConvGammaPt;                       
  TH1F**                  fHistoTrueClusGammaPt;                              
  TH1F**                  fHistoTrueClusConvGammaPt;                          
  TH1F**                  fHistoTrueClusConvGammaFullyPt;                     
  TH1F**                  fHistoTruePrimaryClusGammaPt;                       
  TH1F**                  fHistoTruePrimaryClusConvGammaPt;                   
  TH1F**                  fHistoMultipleCountTrueMeson;                       
  TH1F**                  fHistoMultipleCountTrueConvGamma;                   
  TH1F**                  fHistoMultipleCountTrueClusterGamma;                
  TH1F**                  fHistoNEvents;                                      
  TH1F**                  fHistoNEventsWOWeight;                              
  TH1F**                  fHistoNGoodESDTracks;                               
  TH1F**                  fHistoVertexZ;                                      
  TH1F**                  fHistoVertexX;                                      
  TH1F**                  fHistoVertexY;                                      
  TH1F**                  fHistoNGammaConvCandidates;                         
  TH1F**                  fHistoNGammaCaloCandidates;                         
  TH1F**                  fHistoNV0Tracks;                                    
  TH1F**                  fHistoJetJetNTrials;                                

  // variable to keep track of multiple & missing reco
  map<Int_t,Int_t>        fMapMultipleCountTrueMesons;                        
  map<Int_t,Int_t>        fMapMultipleCountTrueConvGammas;                    
  map<Int_t,Int_t>        fMapMultipleCountTrueClusterGammas;                 
  vector<Int_t>           fVectorRecTrueMesons;                               
  vector<Int_t>           fVectorDoubleCountTrueMesons;                       
  vector<Int_t>           fVectorDoubleCountTrueConvGammas;                   
  vector<Int_t>           fVectorDoubleCountTrueClusterGammas;                

  // additional variables
  Double_t*               fUnsmearedPx;                                       //[fNGammaCandidates]
  Double_t*               fUnsmearedPy;                                       //[fNGammaCandidates]
  Double_t*               fUnsmearedPz;                                       //[fNGammaCandidates]
  Double_t*               fUnsmearedE;                                        //[fNGammaCandidates]
  Double_t*               fMesonInvMassWindow;                                // minimum inv mass for histos

  Int_t*                  fMCEventPos;                                        //[fNGammaCandidates]
  Int_t*                  fMCEventNeg;                                        //[fNGammaCandidates]
  Int_t*                  fESDArrayPos;                                       //[fNGammaCandidates]
  Int_t*                  fESDArrayNeg;                                       //[fNGammaCandidates]

  Double_t                fEventPlaneAngle;                                   // EventPlaneAngle
  Double_t                fMesonInvMassMin;                                   // minimum inv mass for histos
  Double_t                fMesonInvMassMax;                                   // maximum inv mass for histos
  Double_t                fMesonInvMassNBins;                                 // Number of bins for inv mass histos
  Double_t                fWeightJetJetMC;                                    // weight for Jet-Jet MC

  Int_t                   fNGammaCandidates;                                  // number of gamma candidates in event
  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                   fMesonRecoMode;                                     // switch for running with different reconstruction modes: 0 - PCM-PCM, 1 - PCM-Calo, 2 - Calo-Calo
  Int_t                   fMesonType;                                         // selector for meson analysis
  Int_t                   fMesonPDG;                                          // PDG code for selected meson
  Int_t                   fDoMesonQA;                                         // flag for meson QA
  Int_t                   fDoPhotonQA;                                        // flag for photon QA
  Int_t                   fDoClusterQA;                                       // flag for cluster QA
  Int_t                   fIsMC;                                              // flag for MC information

  Bool_t                  fMoveParticleAccordingToVertex;                     // boolean for BG calculation
  Bool_t                  fDoLightOutput;                                     // switch for running light output, kFALSE -> normal mode, kTRUE -> light mode
  Bool_t                  fIsFromDesiredHeader;                               // flag for MC headers
  Bool_t                  fIsOverlappingWithOtherHeader;                      // flag for particles in MC overlapping between headers
  Bool_t                  fDoTHnSparse;                                       // flag for using THnSparses for background estimation
  Bool_t                  fSetPlotHistsExtQA;                                 // flag for extended QA hists
  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
  Bool_t                  fAllowOverlapHeaders;                               // enable overlapping headers for cluster selection
  Bool_t                  fEnableClusterCutsForTrigger;                       // enable CLusterCuts output for trigger only

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

  ClassDef(AliAnalysisTaskHeavyNeutralMesonToGG, 3);
};

#endif // ALIANALYSISTASKHEAVYNEUTRALMESONTOGG_H