AliAnalysisTaskEmcalJetHCorrelations.h

Go to the documentation of this file.

#ifndef AliAnalysisTaskEmcalJetHCorrelations_H
#define AliAnalysisTaskEmcalJetHCorrelations_H

#include <vector>

#include <TRandom3.h>
class TH1;
class TH2;
class TH3;
class THnSparse;

class AliEventPoolManager;

#include "AliEventCuts.h"
#include "AliYAMLConfiguration.h"
#include "THistManager.h"
#include "AliAnalysisTaskEmcalJet.h"
class AliTLorentzVector;
class AliEmcalJet;
class AliJetContainer;
class AliParticleContainer;

// operator<< has to be forward declared carefully to stay in the global namespace so that it works with CINT.
// For generally how to keep the operator in the global namespace, See: https://stackoverflow.com/a/38801633
namespace PWGJE { namespace EMCALJetTasks { class AliAnalysisTaskEmcalJetHCorrelations; } }
std::ostream & operator<< (std::ostream &in, const PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetHCorrelations &myTask);

namespace PWGJE {
namespace EMCALJetTasks {

class AliAnalysisTaskEmcalJetHCorrelations : public AliAnalysisTaskEmcalJet {
 public:
  enum jetBias_t {
    kDisableBias = 10000            
  };

  enum ESingleTrackEfficiency_t {
    kEffDisable = 0,                
    kEffAutomaticConfiguration = 1, 
    kEffPP = 10,                    
  };

  AliAnalysisTaskEmcalJetHCorrelations();
  AliAnalysisTaskEmcalJetHCorrelations(const char *name);
  virtual ~AliAnalysisTaskEmcalJetHCorrelations() {}

  Double_t                GetTrackBias() const                       { return fTrackBias; }
  Double_t                GetClusterBias() const                     { return fClusterBias; }

  // Jet bias - setters
  virtual void            SetTrackBias(Double_t b)                   { fTrackBias    = b; }
  virtual void            SetClusterBias(Double_t b)                 { fClusterBias = b; }

  // Event trigger/mixed selection - setters
  virtual void            SetTriggerType(UInt_t te)                  { fTriggerType = te; }
  virtual void            SetMixedEventTriggerType(UInt_t me)        { fMixingEventType = me; }
  void                    SetDisableFastPartition(Bool_t b = kTRUE)  { fDisableFastPartition = b; }
  Bool_t                  GetDisableFastPartition() const            { return fDisableFastPartition; }
  Bool_t                  GetRequireMatchedJetWhenEmbedding() const   { return fRequireMatchedJetWhenEmbedding; }
  void                    SetRequireMatchedJetWhenEmbedding(Bool_t b) { fRequireMatchedJetWhenEmbedding = b; }
  double                  GetMinimumSharedMomentumFraction() const    { return fMinSharedMomentumFraction; }
  void                    SetMinimumSharedMomentumFraction(double d)  { fMinSharedMomentumFraction = d; }
  double                  GetMaximumMatchedJetDistance() const        { return fMaxMatchedJetDistance; }
  void                    SetMaximumMatchedJetDistance(double d)      { fMaxMatchedJetDistance = d; }
  bool                    GetRequireMatchedPartLevelJet() const       { return fRequireMatchedPartLevelJet; }
  void                    SetRequireMatchedPartLevelJet(bool b)       { fRequireMatchedPartLevelJet = b; }

  // Mixed events
  virtual void            SetEventMixing(Bool_t enable)              { fDoEventMixing = enable;}
  virtual void            SetNumberOfMixingTracks(Int_t tracks)      { fNMixingTracks = tracks; }
  virtual void            SetMinNTracksForMixedEvents(Int_t nmt)     { fMinNTracksMixedEvents = nmt; }
  virtual void            SetMinNEventsForMixedEvents(Int_t nme)     { fMinNEventsMixedEvents = nme; }
  virtual void            SetNCentBinsMixedEvent(Bool_t centbins)    { fNCentBinsMixedEvent = centbins; }
  // Switch to cut out some unneeded sparse axis
  void                    SetDoLessSparseAxes(Bool_t dlsa)           { fDoLessSparseAxes = dlsa; }
  void                    SetDoWiderTrackBin(Bool_t wtrbin)          { fDoWiderTrackBin = wtrbin; }
  // Set efficiency correction
  void                    SetSingleTrackEfficiencyType(ESingleTrackEfficiency_t trackEffType) { fSingleTrackEfficiencyCorrectionType = trackEffType; }
  void                    SetArtificialTrackingInefficiency(double eff) { fArtificialTrackInefficiency = eff; }
  // Setup JES correction
  void                    SetJESCorrectionHist(TH2D * hist)          { fJESCorrectionHist = hist; }
  void                    SetNoMixedEventJESCorrection(Bool_t b) { fNoMixedEventJESCorrection = b; }

  Bool_t                  RetrieveAndInitializeJESCorrectionHist(TString filename, TString histName, Double_t trackBias = AliAnalysisTaskEmcalJetHCorrelations::kDisableBias, Double_t clusterBias = AliAnalysisTaskEmcalJetHCorrelations::kDisableBias);

  // Corrections
  // Public so that it can be tested externally
  Double_t       EffCorrection(Double_t trkETA, Double_t trkPT, AliAnalysisTaskEmcal::BeamType beamType) const;

  virtual void            UserCreateOutputObjects();

  // AddTask
  static AliAnalysisTaskEmcalJetHCorrelations * AddTaskEmcalJetHCorrelations(
     const char *nTracks              = "usedefault",
     const char *nCaloClusters        = "usedefault",
     // Jet options
     const Double_t trackBias         = 5,
     const Double_t clusterBias       = 5,
     // Mixed event options
     const Int_t nTracksMixedEvent    = 0,  // Additionally acts as a switch for enabling mixed events
     const Int_t minNTracksMixedEvent = 5000,
     const Int_t minNEventsMixedEvent = 5,
     const UInt_t nCentBinsMixedEvent = 10,
     // Triggers
     UInt_t trigEvent                 = AliVEvent::kAny,
     UInt_t mixEvent                  = AliVEvent::kAny,
     // Options
     const Bool_t lessSparseAxes      = kFALSE,
     const Bool_t widerTrackBin       = kFALSE,
     // Corrections
     const AliAnalysisTaskEmcalJetHCorrelations::ESingleTrackEfficiency_t singleTrackEfficiency = AliAnalysisTaskEmcalJetHCorrelations::kEffDisable,
     const Bool_t JESCorrection = kFALSE,
     const char * JESCorrectionFilename = "alien:///alice/cern.ch/user/r/rehlersi/JESCorrection.root",
     const char * JESCorrectionHistName = "JESCorrection",
     const char *suffix               = "biased"
   );

  bool ConfigureForStandardAnalysis(std::string trackName = "usedefault",
    std::string clusName = "usedefault",
    const double jetConstituentPtCut = 3,
    const double trackEta = 0.8,
    const double jetRadius = 0.2);

  bool ConfigureForEmbeddingAnalysis(std::string trackName = "usedefault",
    std::string clusName = "caloClustersCombined",
    const double jetConstituentPtCut = 3,
    const double trackEta = 0.8,
    const double jetRadius = 0.2,
    const std::string & jetTag = "hybridLevelJets",
    const std::string & correlationsTracksCutsPeriod = "lhc11a");

  // Task configuration
  void AddConfigurationFile(const std::string & configurationPath, const std::string & configName = "") { fYAMLConfig.AddConfiguration(configurationPath, configName); }
  bool Initialize();

  // Printing
  std::string toString() const;
  friend std::ostream & ::operator<<(std::ostream &in, const AliAnalysisTaskEmcalJetHCorrelations &myTask);
  void Print(Option_t* opt = "") const;
  std::ostream & Print(std::ostream &in) const;

 protected:

  // NOTE: This is not an ideal way to resolve the size of histogram initialization.
  //       Will be resolved when we move fully to the THnSparse
  enum binArrayLimits_t {
    kMaxTrackPtBins = 7,             
    kMaxCentralityBins = 5,          
    kMixedEventMultiplicityBins = 8, 
  };

  // EMCal framework functions
  virtual void UserExecOnce();
  Bool_t IsEventSelected();
  Bool_t Run();

  // Utility functions
  AliParticleContainer * CreateParticleOrTrackContainer(const std::string & collectionName) const;
  // Determine if a jet has been matched
  bool CheckForMatchedJet(AliJetContainer * jets, AliEmcalJet * jet, const std::string & histName);
  // Apply artificial tracking inefficiency
  bool CheckArtificialTrackEfficiency(unsigned int trackIndex, std::vector<unsigned int> & rejectedTrackIndices, bool useRejectedList);
  // Reduce event mixing memory usage
  TObjArray*             CloneAndReduceTrackList(std::vector<unsigned int> & rejectedTrackIndices, const bool useRejectedList);
  // Histogram helper functions
  virtual THnSparse*     NewTHnSparseF(const char* name, UInt_t entries);
  virtual void           GetDimParams(Int_t iEntry,TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax);
  // Binning helper functions
  Int_t                  GetTrackPtBin(Double_t pt) const;
  UInt_t                 RetrieveTriggerMask() const;
  // Helper functions
  void                   InitializeArraysToZero();
  void                   GetDeltaEtaDeltaPhiDeltaR(AliTLorentzVector & particleOne, AliVParticle * particleTwo, Double_t & deltaEta, Double_t & deltaPhi, Double_t & deltaR);
  Double_t               GetRelativeEPAngle(Double_t jetAngle, Double_t epAngle) const;
  // Test for biased jet
  Bool_t                 BiasedJet(AliEmcalJet * jet);
  // Corrections
  Double_t               EffCorrection(Double_t trkETA, Double_t trkPT) const;

  // Fill methods which allow for the JES correction
  void                   FillHist(TH1 * hist, Double_t fillValue, Double_t weight = 1.0, Bool_t noCorrection = kFALSE);
  void                   FillHist(THnSparse * hist, Double_t *fillValue, Double_t weight = 1.0, Bool_t noCorrection = kFALSE);
  void                   AccessSetOfYBinValues(TH2D * hist, Int_t xBin, std::vector <Double_t> & yBinsContent, Double_t scaleFactor = -1.0);

  // Configuration
  void RetrieveAndSetTaskPropertiesFromYAMLConfig();

  // Configuration
  PWG::Tools::AliYAMLConfiguration fYAMLConfig;   
  bool fConfigurationInitialized;                 
  // Event cuts
  AliEventCuts fEventCuts;                        
  bool fUseAliEventCuts;                          
  // Jet bias
  Double_t               fTrackBias;               
  Double_t               fClusterBias;             
  // Event Mixing
  Bool_t                 fDoEventMixing;           
  Int_t                  fNMixingTracks;           
  Int_t                  fMinNTracksMixedEvents;   
  Int_t                  fMinNEventsMixedEvents;   
  UInt_t                 fNCentBinsMixedEvent;     
  AliEventPoolManager   *fPoolMgr;                 
  // Event selection types
  UInt_t                 fTriggerType;             
  UInt_t                 fMixingEventType;         
  Bool_t                 fDisableFastPartition;    
  // Efficiency correction
  TRandom3 fRandom;                               
  ESingleTrackEfficiency_t fSingleTrackEfficiencyCorrectionType; 
  Double_t               fArtificialTrackInefficiency; 
  // JES correction
  Bool_t                 fNoMixedEventJESCorrection; 
  TH2D                  *fJESCorrectionHist;       
  // Histogram binning variables
  Bool_t                 fDoLessSparseAxes;        
  Bool_t                 fDoWiderTrackBin;         
  Bool_t                 fRequireMatchedJetWhenEmbedding; 
  Double_t               fMinSharedMomentumFraction; 
  bool                   fRequireMatchedPartLevelJet; 
  Double_t               fMaxMatchedJetDistance;  

  // Histograms
  THistManager           fHistManager;             
  TH1                   *fHistJetHTrackPt;         
  TH2                   *fHistJetEtaPhi;           
  TH2                   *fHistTrackEtaPhi[7];      
  TH2                   *fHistJetHEtaPhi;          

  TH1                   *fHistJetPt[6];            
  TH1                   *fHistJetPtBias[6];        
  THnSparse             *fhnMixedEvents;           
  THnSparse             *fhnJH;                    
  THnSparse             *fhnTrigger;               

  // Pb-Pb Efficiency correction coefficients
  static Double_t p0_10SG[17];                    
  static Double_t p10_30SG[17];                   
  static Double_t p30_50SG[17];                   
  static Double_t p50_90SG[17];                   
  // Good Runs
  static Double_t p0_10G[17];                     
  static Double_t p10_30G[17];                    
  static Double_t p30_50G[17];                    
  static Double_t p50_90G[17];                    

 private:

  AliAnalysisTaskEmcalJetHCorrelations(const AliAnalysisTaskEmcalJetHCorrelations&); // not implemented
  AliAnalysisTaskEmcalJetHCorrelations& operator=(const AliAnalysisTaskEmcalJetHCorrelations&); // not implemented

  ClassDef(AliAnalysisTaskEmcalJetHCorrelations, 17);
};

} /* namespace EMCALJetTasks */
} /* namespace PWGJE */

#endif