AliAnalysisTaskEmcalJetPerformance.h

Go to the documentation of this file.

#ifndef AliAnalysisTaskEmcalJetPerformance_H
#define AliAnalysisTaskEmcalJetPerformance_H

/**********************************************************************************
 * Copyright (C) 2016, Copyright Holders of the ALICE Collaboration                *
 * All rights reserved.                                                            *
 *                                                                                 *
 * Redistribution and use in source and binary forms, with or without              *
 * modification, are permitted provided that the following conditions are met:     *
 *   * Redistributions of source code must retain the above copyright              *
 *     notice, this list of conditions and the following disclaimer.               *
 *   * Redistributions in binary form must reproduce the above copyright           *
 *     notice, this list of conditions and the following disclaimer in the         *
 *     documentation and/or other materials provided with the distribution.        *
 *   * Neither the name of the <organization> nor the                              *
 *     names of its contributors may be used to endorse or promote products        *
 *     derived from this software without specific prior written permission.       *
 *                                                                                 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND *
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED   *
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE          *
 * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY             *
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES      *
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;    *
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND     *
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT      *
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS   *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                    *
 * *********************************************************************************/

#include "THistManager.h"

#include "AliEventCuts.h"
#include "AliAnalysisTaskEmcalJet.h"
#include "AliEmcalEmbeddingQA.h"

class AliAnalysisTaskEmcalJetPerformance : public AliAnalysisTaskEmcalJet {
 public:

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

  static AliAnalysisTaskEmcalJetPerformance* AddTaskEmcalJetPerformance(
    const char *ntracks            = "usedefault",
    const char *nclusters          = "usedefault",
    const char *nGenLev            = "mcparticles",
    const Double_t minTrPt         = 0.15,              // Minimum track pT in standard track container
    const Double_t minClPt         = 0.30,              // Minimum cluster E in standard cluster container
    const char *suffix             = "");
  
  // Truth-level particle types
  enum ContributorType {
    kUndefined      = -1,  
    kPhoton         = 0,   
    kChargedPion    = 1,   
    kProton         = 2,   
    kAntiProton     = 3,   
    kChargedKaon    = 4,   
    kK0L            = 5,   
    kNeutron        = 6,   
    kAntiNeutron    = 7,   
    kElectron       = 8,   
    kMuon           = 9,   
    kOther          = 10   
  };
  
  // Detector-level particle types, based on PhysicalPrimary contributors
  enum ParticleType {
    kNotDefined               = -1, 
    kSinglePhoton             = 0,  
    kSingleElectron           = 1,  
    kSingleChargedPion        = 2,  
    kSingleProton             = 3,  
    kSingleAntiProton         = 4,  
    kSingleChargedKaon        = 5,  
    kSingleK0L                = 6,  
    kSingleNeutron            = 7,  
    kSingleAntiNeutron        = 8,  
    kSingleOther              = 9,  
    kPhotonHadron             = 10, 
    kHadronPhoton             = 11, 
    kMergedPi0                = 12, 
    kPhotonPhotonOther        = 13, 
    kHadronHadron             = 14, 
    kTwoContributorsOther     = 15, 
    kMoreThanTwoContributors  = 16  
  };
  
  enum ClusterType {
    kNA       = -1,
    kEMCal    = 0, 
    kDCal     = 1, 
  };

  void UserCreateOutputObjects()                                                ;
  
  // Setters
  void SetMinPt(Double_t d)                                 { fMinPt = d; }
  void SetMaxPt(Double_t d)                                 { fMaxPt = d; }
  void SetUseAliEventCuts(Bool_t b)                         { fUseAliEventCuts = b; }
  void SetUseManualEvtCuts(Bool_t input)                    { fUseManualEventCuts = input;}
  void SetPlotJetHistograms(Bool_t b)                       { fPlotJetHistograms = b; }
  void SetPlotClusterHistograms(Bool_t b)                   { fPlotClusterHistograms = b; }
  void SetPlotParticleCompositionHistograms(Bool_t b)       { fPlotParticleCompositionHistograms = b; }
  void SetComputeBackground(Bool_t b)                       { fComputeBackground = b; }
  void SetDoTriggerSimulation(Bool_t b)                     { fDoTriggerSimulation = b; }
  void SetPlotMatchedJetHistograms(Bool_t b)                { fPlotMatchedJetHistograms = b; }
  void SetComputeMBDownscaling(Bool_t b)                    { fComputeMBDownscaling = b; }
  void SetTrackMatchingDeltaEtaMax(Double_t deta)           { fTrackMatchingDeltaEtaMax = deta; }
  void SetTrackMatchingDeltaPhiMax(Double_t dphi)           { fTrackMatchingDeltaPhiMax = dphi; }
  void SetPlotDCal(Bool_t b)                                { fPlotDCal = b; }
  void SetDoJetMatchingGeometrical(Bool_t b)                { fDoJetMatchingGeometrical = b; }
  void SetDoJetMatchingMCFraction(Bool_t b)                 { fDoJetMatchingMCFraction = b; }
  void SetRequireMatchedJetAccepted(Bool_t b)               { fRequireMatchedJetAccepted = b; }
  void SetJetMatchingR(Double_t r)                          { fJetMatchingR = r; }
  void SetMinimumSharedMomentumFraction(double d)           { fMinSharedMomentumFraction = d; }
  void SetMCJetMinMatchingPt(Double_t min)                  { fMCJetMinMatchingPt = min; }
  void SetPlotJetMatchCandThresh(Double_t r)                { fPlotJetMatchCandThresh = r; };
  void SetDoTriggerResponse(Bool_t b)                       { fDoTriggerResponse = b; };
  void SetDoClosureTest(Bool_t b)                           { fDoClosureTest = b; }
  void SetFillChargedFluctuations(Bool_t b)                 { fFillChargedFluctuations = b; }


 protected:
  virtual void                ExecOnce()                                        ;
  virtual Bool_t              FillHistograms()                                  ;
  virtual Bool_t              Run()                                             ;
  virtual Bool_t              IsEventSelected()                                 ;
  virtual void                RunChanged(Int_t run)                             ;

  // Analysis and plotting functions
  void                        GenerateHistoBins()                               ;
  void                        AllocateJetHistograms()                           ;
  void                        AllocateClusterHistograms()                       ;
  void                        AllocateParticleCompositionHistograms()           ;
  void                        AllocateBackgroundHistograms()                    ;
  void                        AllocateTriggerSimHistograms()                    ;
  void                        AllocateMatchedJetHistograms()                    ;
  void                        FillJetHistograms()                               ;
  void                        FillClusterHistograms()                           ;
  void                        FillParticleCompositionHistograms()               ;
  void                        FillParticleCompositionClusterHistograms(const AliMCEvent* mcevent);
  void                        FillParticleCompositionJetHistograms(const AliMCEvent* mcevent);
  void                        SetParticleTypeLabels(TAxis* axis)                ;
  void                        ComputeBackground()                               ;
  void                        DoTriggerSimulation()                             ;
  void                        FillTriggerSimHistograms()                        ;
  void                        FillMatchedJetHistograms()                        ;
  void                        ComputeJetMatches(AliJetContainer* jetCont1, AliJetContainer* jetCont2, Bool_t bUseJetCont2Acceptance);
  void                        SetJetClosestCandidate(AliEmcalJet* jet1, AliEmcalJet* jet2);
  const AliEmcalJet*          GetMatchedPartLevelJet(const AliEmcalJet* jet, Double_t detJetPt);
  
  // Utility functions
  Double_t                    GetJetPt(const AliEmcalJet* jet, Double_t rho);
  Double_t                    GetDeltaR(const AliTLorentzVector* part, Double_t etaRef, Double_t phiRef);
  Double_t                    GetJetType(const AliEmcalJet* jet);
  ContributorType             GetContributorType(const AliVCluster* clus, const AliMCEvent* mcevent, Int_t label);
  Bool_t                      IsHadron(const ContributorType contributor);
  Bool_t                      IsSignalJetOverlap(Bool_t isTrack, Int_t particleID, const AliJetContainer* jet, Int_t maxJetIds[]);
  // Analysis parameters
  Bool_t                      fPlotJetHistograms;                   
  Bool_t                      fPlotClusterHistograms;               
  Bool_t                      fPlotParticleCompositionHistograms;   
  Bool_t                      fComputeBackground;                   
  Bool_t                      fDoTriggerSimulation;                 
  Bool_t                      fPlotMatchedJetHistograms;            
  Bool_t                      fComputeMBDownscaling;                
  Bool_t                      fPlotDCal;                            
  Bool_t                      fDoClosureTest;                       
  Bool_t                      fFillChargedFluctuations;             
  // Plotting parameters
  Double_t                    fMinPt;                               
  Double_t                    fMaxPt;                               
  Int_t                       fNEtaBins;                            
  Int_t                       fNPhiBins;                            
  Int_t                       fNCentHistBins;                       
  Double_t*                   fCentHistBins;                        
  Int_t                       fNPtHistBins;                         
  Double_t*                   fPtHistBins;                          
  Int_t                       fNM02HistBins;                        
  Double_t*                   fM02HistBins;                         
  Int_t                       fNEoverPBins;                         
  Double_t*                   fEoverPBins;                          
  
  // Track matching parameters (for cluster histogram plots)
  Double_t                    fTrackMatchingDeltaEtaMax;            
  Double_t                    fTrackMatchingDeltaPhiMax;            
  
  // Trigger parameters
  Double_t                    fMBUpscaleFactor;                     
  Double_t                    fMedianEMCal;                         
  Double_t                    fMedianDCal;                          
  Bool_t                      fkEMCEJE;                             
  Bool_t                      fDoTriggerResponse;                   
  
  // Embedding parameters
  Bool_t                      fDoJetMatchingGeometrical;            
  Bool_t                      fDoJetMatchingMCFraction;             
  AliEmcalEmbeddingQA         fEmbeddingQA;                         
  AliJetContainer*            fMCJetContainer;                      
  AliJetContainer*            fDetJetContainer;                     
  AliJetContainer*            fDetJetContainerPPIntermediate;       
  Bool_t                      fRequireMatchedJetAccepted;           
  Double_t                    fJetMatchingR;                        
  Double_t                    fMinSharedMomentumFraction;           
  Double_t                    fMCJetMinMatchingPt;                  
  Double_t                    fPlotJetMatchCandThresh;              
  
  // Event selection
  Bool_t                      fUseAliEventCuts;                     
  AliEventCuts                fEventCuts;                           
  TList                      *fEventCutList;                        
  Bool_t                      fUseManualEventCuts;                  
  
  // MC options
  AliMCParticleContainer*     fGeneratorLevel;                      
  
  // Hist manager
  THistManager                fHistManager;                         

 private:
  AliAnalysisTaskEmcalJetPerformance(const AliAnalysisTaskEmcalJetPerformance&)           ; // not implemented
  AliAnalysisTaskEmcalJetPerformance &operator=(const AliAnalysisTaskEmcalJetPerformance&); // not implemented

  ClassDef(AliAnalysisTaskEmcalJetPerformance, 20);
};
#endif