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;}

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

  // 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:
  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**                             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
  TClonesArray*                       fReaderGammas;          // Array with conversion photons selected by V0Reader Cut
  TList*                              fGammaCandidates;       // current list of photon candidates
  TList*                              fClusterCandidates;     
  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;                  

  //histograms for mesons reconstructed quantities
  TH2F**                  fHistoMotherInvMassPt;              
  TH2F**                  fHistoMotherMatchedInvMassPt;       
  THnSparseF**            fSparseMotherInvMassPtZM;           
  TH2F**                  fHistoMotherBackInvMassPt;          
  THnSparseF**            fSparseMotherBackInvMassPtZM;       
  TH2F**                  fHistoMotherMesonPtY;               
  TH2F**                  fHistoMotherMesonPtAlpha;           
  TH2F**                  fHistoMotherMesonPtOpenAngle;       
  TH2F**                  fHistoMotherMesonConvPhotonEtaPhi;  

  // 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 mesaon analysis
  TH1F**                  fHistoMCMesonPt;                      
  TH1F**                  fHistoMCMesonWOWeightPt;              
  TH1F**                  fHistoMCMesonWOEvtWeightPt;           
  TH1F**                  fHistoMCMesonInAccPt;                 
  TH1F**                  fHistoMCMesonWOWeightInAccPt;         
  TH1F**                  fHistoMCMesonWOEvtWeightInAccPt;      
  TH2F**                  fHistoMCMesonPtY;                     
  TH2F**                  fHistoMCMesonPtAlpha;                 
  TH2F**                  fHistoMCMesonPtJetPt;                 

  // MC validated reconstructed quantities mesons
  TH2F**                  fHistoTrueMesonInvMassPt;                             
  TH2F**                  fHistoTrueMesonMatchedInvMassPt;                      
  TH2F**                  fHistoTrueMesonCaloPhotonInvMassPt;                   
  TH2F**                  fHistoTrueMesonCaloConvertedPhotonInvMassPt;          
  TH2F**                  fHistoTrueMesonCaloMixedPhotonConvPhotonInvMassPt;    
  TH2F**                  fHistoTrueMesonCaloConvertedPhotonMatchedInvMassPt;   
  TH2F**                  fHistoTrueMesonCaloElectronInvMassPt;                 
  TH2F**                  fHistoTrueMesonCaloMergedClusterInvMassPt;            
  TH2F**                  fHistoTrueMesonCaloMergedClusterPartConvInvMassPt;    
  TH2F**                  fHistoTruePrimaryMesonInvMassPt;                      
  TH2F**                  fHistoTruePrimaryMesonW0WeightingInvMassPt;           
  TProfile2D**            fProfileTruePrimaryMesonWeightsInvMassPt;             
  TH2F**                  fHistoTruePrimaryMesonMCPtResolPt;                    
  TH2F**                  fHistoTrueMotherMesonConvPhotonEtaPhi;                
  TH2F**                  fHistoTrueBckGGInvMassPt;                             
  TH2F**                  fHistoTrueBckFullMesonContainedInOneClusterInvMassPt; 
  TH2F**                  fHistoTrueBckAsymEClustersInvMassPt;                  
  TH2F**                  fHistoTrueBckContInvMassPt;                           
  TH2F**                  fHistoTrueMesonPtY;                                   
  TH2F**                  fHistoTrueMesonPtAlpha;                               
  TH2F**                  fHistoTrueMesonPtOpenAngle;                           

  // MC validated reconstructed quantities photons
  TH1F**                  fHistoTrueConvGammaPt;                              
  TH1F**                  fHistoTruePrimaryConvGammaPt;                       

  TH1F**                  fHistoTrueClusGammaPt;                              
  TH1F**                  fHistoTrueClusConvGammaPt;                          
  TH1F**                  fHistoTrueClusConvGammaFullyPt;                     
  TH2F**                  fHistoTrueNLabelsInClusPt;                          
  TH1F**                  fHistoTruePrimaryClusGammaPt;                       
  TH1F**                  fHistoTruePrimaryClusConvGammaPt;                   

  // variable to keep track of multiple & missing reco
  vector<Int_t>           fVectorRecTrueMesons;                                 
  TH2F**                  fHistoDoubleCountTrueMesonInvMassPt;                  
  TH2F**                  fHistoDoubleCountTrueConvGammaRPt;                  
  TH2F**                  fHistoDoubleCountTrueClusterGammaPt;                
  vector<Int_t>           fVectorDoubleCountTrueMesons;                         
  vector<Int_t>           fVectorDoubleCountTrueConvGammas;                   
  vector<Int_t>           fVectorDoubleCountTrueClusterGammas;                
  TH1F**                  fHistoMultipleCountTrueMeson;                         
  TH1F**                  fHistoMultipleCountTrueConvGamma;                   
  TH1F**                  fHistoMultipleCountTrueClusterGamma;                
  map<Int_t,Int_t>        fMapMultipleCountTrueMesons;                          
  map<Int_t,Int_t>        fMapMultipleCountTrueConvGammas;                    
  map<Int_t,Int_t>        fMapMultipleCountTrueClusterGammas;                 

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

  // 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
  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
  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*               fMesonInvMassWindow;                                // minimum inv mass for histos
  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

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

  ClassDef(AliAnalysisTaskHeavyNeutralMesonToGG, 1);
};

#endif // ALIANALYSISTASKHEAVYNEUTRALMESONTOGG_H