AliAnalysisTaskEmcalDijetImbalance.h

Go to the documentation of this file.

#ifndef AliAnalysisTaskEmcalDijetImbalance_H
#define AliAnalysisTaskEmcalDijetImbalance_H

/* Copyright(c) 1998-2016, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

class AliPHOSGeometry;

#include "THistManager.h"

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

class AliAnalysisTaskEmcalDijetImbalance : public AliAnalysisTaskEmcalJet {
 public:
  
  // Struct to store all relevant info of a di-jet pair
  struct Dijet_t {
    Dijet_t() : leadingHadronCutType(0), trigJet(0), trigJetPt(0), trigJetPhi(0), trigJetEta(0),
                assJet(0), assJetPt(0), assJetPhi(0), assJetEta(0), isAccepted(kFALSE), deltaPhi(0), deltaEta(0), AJ(0), xJ(0), kTy(0) {}
    
    Int_t leadingHadronCutType;
    
    AliEmcalJet* trigJet;
    Double_t trigJetPt;
    Double_t trigJetPhi;
    Double_t trigJetEta;
    
    AliEmcalJet* assJet;
    Double_t assJetPt;
    Double_t assJetPhi;
    Double_t assJetEta;
    
    Bool_t isAccepted;
    
    Double_t deltaPhi;
    Double_t deltaEta;
    Double_t AJ;
    Double_t xJ;
    Double_t kTy;
    
    void clear() {leadingHadronCutType=0; trigJet=0; trigJetPt=0; trigJetPhi=0; trigJetEta=0;
                    assJet=0; assJetPt=0; assJetPhi=0; assJetEta=0; isAccepted=kFALSE; deltaPhi=0; deltaEta=0; AJ=0; xJ=0; kTy=0;}
  };
  
  enum ClusterType {
    kNA       = -1,
    kEMCal    = 0, 
    kDCal     = 1, 
    kPHOS     = 2  
  };

  AliAnalysisTaskEmcalDijetImbalance()                                          ;
  AliAnalysisTaskEmcalDijetImbalance(const char *name)                          ;
  virtual ~AliAnalysisTaskEmcalDijetImbalance()                                 ;
  
  static AliAnalysisTaskEmcalDijetImbalance* AddTaskEmcalDijetImbalance(const char *ntracks = "usedefault",
                                                                        const char *nclusters = "usedefault",
                                                                        const Double_t deltaPhiMin = 2*TMath::Pi()/3,
                                                                        const Bool_t doGeomMatching = kFALSE,
                                                                        const Double_t minTrPtHardCore = 3.0,
                                                                        const Double_t minClPtHardCore = 3.0,
                                                                        const Double_t jetR = 0.2,
                                                                        const Bool_t includePHOS = kTRUE,
                                                                        const Double_t minTrPt = 0.15,
                                                                        const Double_t minClPt = 0.30,
                                                                        const char *suffix = "");

  void UserCreateOutputObjects()                                                ;
  void LoadBackgroundScalingHistogram(const char* path = "alien:///alice/cern.ch/user/j/jmulliga/scaleFactorEMCalLHC15o.root", const char* name1 = "hEtaPhiSFCorrection", const char* name2 = "hEtaPhiJetPtCorrection");
  
  // Setters
  void SetDeltaPhiCut(Double_t d)                           { fDeltaPhiMin = d; }
  void SetMaxPt(Double_t d)                                 { fMaxPt = d; }
  void SetPlotDijetCandHistograms(Bool_t b)                 { fPlotDijetCandHistograms = b; }
  void SetPlotDijetImbalanceHistograms(Bool_t b)            { fPlotDijetImbalanceHistograms = b; }
  void SetComputeBackground(Bool_t b)                       { fComputeBackground = b; }
  void SetDoMomentumBalance(Bool_t b)                       { fDoMomentumBalance = b; }
  void SetDoGeometricalMatching(Bool_t b, Double_t r, Double_t trackThresh, Double_t clusThresh)
    { fDoGeometricalMatching = b; fMatchingJetR = r; fTrackConstituentThreshold = trackThresh; fClusterConstituentThreshold = clusThresh;}
  void SetDoTriggerSimulation(Bool_t b)                     { fDoTriggerSimulation = b; }
  void SetLoadBackgroundScalingWeights(Bool_t b)            { fLoadBackgroundScalingWeights = b; }
  void SetComputeMBDownscaling(Bool_t b)                    { fComputeMBDownscaling = b; }
  void SetMinTrigJetPt(Double_t p)                          { fMinTrigJetPt = p; }
  void SetMinAssJetPt(Double_t p)                           { fMinAssJetPt = p; }
  void SetDijetLeadingHadronPt(Double_t pt)                 { fDijetLeadingHadronPt = pt; }
  void SetUseAliEventCuts(Bool_t b)                         { fUseAliEventCuts = b; }
  void SetUseManualEvtCuts(Bool_t input)                    { fUseManualEventCuts = input;}
  void SetNEtaBins(Int_t n)                                 { fNEtaBins = n; }
  void SetNPhiBins(Int_t n)                                 { fNPhiBins = n; }

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

  // Analysis and plotting functions
  void                        GenerateHistoBins()                               ;
  void                        AllocateBackgroundHistograms()                    ;
  void                        AllocateDijetCandHistograms()                     ;
  void                        AllocateDijetImbalanceHistograms()                ;
  void                        AllocateMomentumBalanceHistograms()               ;
  void                        AllocateGeometricalMatchingHistograms()           ;
  void                        AllocateTriggerSimHistograms()                    ;
  void                        FindDijet(AliJetContainer* jetCont, Int_t leadingHadronCutBin);
  void                        ComputeBackground()                               ;
  void                        DoMomentumBalance(TString histname)               ;
  void                        DoGeometricalMatching()                           ;
  void                        DoTriggerSimulation()                             ;
  void                        FindMatchingDijet(AliJetContainer* jetCont)       ;
  void                        FillDijetCandHistograms(AliJetContainer* jets)    ;
  void                        FillDijetImbalanceHistograms(AliJetContainer* jets);
  void                        FillMomentumBalanceHistograms(TString histname, Double_t deltaPhi, Double_t trackPt, Double_t balancePt);
  void                        FillGeometricalMatchingHistograms()               ;
  void                        FillTriggerSimHistograms()                        ;
  
  // Utility functions
  Double_t                    GetJetPt(AliJetContainer* jetCont, AliEmcalJet* jet);
  AliEmcalJet*                GetLeadingJet(AliJetContainer* jetCont);
  Double_t                    GetDeltaR(AliEmcalJet* jet1, AliEmcalJet* jet2);
  Double_t                    GetDeltaR(AliTLorentzVector* part, Double_t etaRef, Double_t phiRef);
  Double_t                    GetJetType(AliEmcalJet* jet);
  
  // Analysis parameters
  Double_t                    fDeltaPhiMin;                         
  Double_t                    fMinTrigJetPt;                        
  Double_t                    fMinAssJetPt;                         
  Double_t                    fDijetLeadingHadronPt;                
  Double_t                    fMatchingJetR;                        
  Double_t                    fTrackConstituentThreshold;           
  Double_t                    fClusterConstituentThreshold;         
  Dijet_t                     fDijet;                               
  Dijet_t                     fMatchingDijet;                       
  Int_t                       fNEtaBins;                            
  Int_t                       fNPhiBins;                            
  TH2D*                       fBackgroundScalingWeights;            
  TH2D*                       fGapJetScalingWeights;                

  // Analysis configuration and plotting options
  Bool_t                      fPlotDijetCandHistograms;             
  Bool_t                      fPlotDijetImbalanceHistograms;        
  Bool_t                      fComputeBackground;                   
  Bool_t                      fDoMomentumBalance;                   
  Bool_t                      fDoGeometricalMatching;               
  Bool_t                      fLoadBackgroundScalingWeights;        
  Bool_t                      fComputeMBDownscaling;                
  Bool_t                      fDoTriggerSimulation;                 

  // Plotting parameters
  Float_t                     fMaxPt;                               
  Int_t                       fNCentHistBins;                       
  Double_t*                   fCentHistBins;                        
  Int_t                       fNPtHistBins;                         
  Double_t*                   fPtHistBins;                          
  
  // Event selection
  Bool_t                      fUseAliEventCuts;                     
  AliEventCuts                fEventCuts;                           
  TList                      *fEventCutList;                        
  Bool_t                      fUseManualEventCuts;                  
  
  // Trigger parameters
  Double_t                    fMBUpscaleFactor;                     
  Double_t                    fMedianEMCal;                         
  Double_t                    fMedianDCal;                          
  Bool_t                      fkEMCEJE;                             
  
  // Embedding parameters
  AliEmcalEmbeddingQA         fEmbeddingQA;                         
  
  // Hist manager
  THistManager                fHistManager;                         

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

  ClassDef(AliAnalysisTaskEmcalDijetImbalance, 14);
};
#endif