AliAnalysisTaskEmcal.h

Go to the documentation of this file.

/************************************************************************************
 * Copyright (C) 2017, 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.                     *
 ************************************************************************************/
#ifndef ALIANALYSISTASKEMCAL_H
#define ALIANALYSISTASKEMCAL_H

class TClonesArray;
class TString;
class AliMCParticle;
class AliVCluster;
class AliVTrack;
class AliVParticle;
class AliVCaloCells;
class TH1;
class TProfile;
class AliEMCALGeometry;
class AliGenPythiaEventHeader;
class AliGenHerwigEventHeader;
class AliVCaloTrigger;
class AliAnalysisUtils;
class AliEMCALTriggerPatchInfo;
class AliAODTrack;
class AliEmcalPythiaInfo;
class AliAODInputHandler;
class AliESDInputHandler;

#include "Rtypes.h"
#include "TArrayI.h"

#include "AliParticleContainer.h"
#include "AliMCParticleContainer.h"
#include "AliTrackContainer.h"
#include "AliClusterContainer.h"
#include "AliEmcalList.h"
#include "AliEventCuts.h"

#include "AliAnalysisTaskSE.h"
class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
 public:

  enum EDataType_t {
    kUnknownDataType,
    kESD,
    kAOD
  };

  enum BeamType {
    kNA       = -1,
    kpp       = 0, 
    kAA       = 1, 
    kpA       = 2  
  };

  enum TriggerType {
    kND       = -1,
    kJ1       = 0, 
    kJ2       = 1, 
    kG1       = 2, 
    kG2       = 3, 
    kL0       = 4  
  };

  enum TriggerCategory {
    kTriggerLevel0      = 0,   
    kTriggerLevel1Jet   = 1,   
    kTriggerLevel1Gamma = 2,   
    kTriggerRecalcJet   = 3,   
    kTriggerRecalcGamma = 4    
  };

  enum EMCalTriggerMode_t {
    kNoSpecialTreatment,       
    kOverlapWithLowThreshold   
  };

  AliAnalysisTaskEmcal();

  AliAnalysisTaskEmcal(const char *name, Bool_t histo=kFALSE);

  virtual ~AliAnalysisTaskEmcal();

  AliParticleContainer       *AddParticleContainer(const char *n);

  AliTrackContainer          *AddTrackContainer(const char *n);

  AliMCParticleContainer     *AddMCParticleContainer(const char *n);

  AliClusterContainer        *AddClusterContainer(const char *n);

  void                        AdoptParticleContainer(AliParticleContainer* cont)    { fParticleCollArray.Add(cont)                        ; }
  void                        AdoptTrackContainer(AliTrackContainer* cont)          { AdoptParticleContainer(cont)                        ; }
  void                        AdoptMCParticleContainer(AliMCParticleContainer* cont){ AdoptParticleContainer(cont)                        ; }
  void                        AdoptClusterContainer(AliClusterContainer* cont)      { fClusterCollArray.Add(cont)                         ; }

  AliParticleContainer       *GetParticleContainer(Int_t i=0)         const;

  AliParticleContainer       *GetParticleContainer(const char* name)  const;

  AliClusterContainer        *GetClusterContainer(Int_t i=0)          const;

  AliClusterContainer        *GetClusterContainer(const char* name)   const;
  AliMCParticleContainer     *GetMCParticleContainer(Int_t i=0)               const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(i))   ; }
  AliMCParticleContainer     *GetMCParticleContainer(const char* name)        const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(name)); }
  AliTrackContainer          *GetTrackContainer(Int_t i=0)                    const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(i))        ; }
  AliTrackContainer          *GetTrackContainer(const char* name)             const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(name))     ; }
  AliEventCuts               &GetEventCuts()                                        { return fAliEventCuts; }
  void                        RemoveParticleContainer(Int_t i=0)                    { fParticleCollArray.RemoveAt(i)                      ; } 
  void                        RemoveClusterContainer(Int_t i=0)                     { fClusterCollArray.RemoveAt(i)                       ; } 
  void                        SetCaloCellsName(const char *n)                       { fCaloCellsName     = n                              ; }
  void                        SetCaloTriggerPatchInfoName(const char *n)            { fCaloTriggerPatchInfoName = n                       ; }
  void                        SetCaloTriggersName(const char *n)                    { fCaloTriggersName  = n                              ; }
  void                        SetCentRange(Double_t min, Double_t max)              { fMinCent           = min  ; fMaxCent = max          ; }
  void                        SetCentralityEstimator(const char *c)                 { fCentEst           = c                              ; }

  void                        SetClusPtCut(Double_t cut, Int_t c=0);

  void                        SetClusTimeCut(Double_t min, Double_t max, Int_t c=0);

  void                        SetEventPlaneVsEmcal(Double_t ep)                     { fEventPlaneVsEmcal = ep                             ; }
  void                        SetForceBeamType(BeamType f)                          { fForceBeamType     = f                              ; }
  void                        SetHistoBins(Int_t nbins, Double_t min, Double_t max) { fNbins = nbins; fMinBinPt = min; fMaxBinPt = max    ; }
  void                        SetRecycleUnusedEmbeddedEventsMode(Bool_t b)          { fRecycleUnusedEmbeddedEventsMode = b                ; }
  void                        SetIsEmbedded(Bool_t i)                               { fIsEmbedded        = i                              ; }
  void                        SetIsPythia(Bool_t i)                                 { fIsPythia          = i                              ; }
  void                        SetIsHerwig(Bool_t i)                                 { fIsHerwig          = i                              ; }
  void                        SetMakeGeneralHistograms(Bool_t g)                    { fGeneralHistograms = g                              ; }

  void                        SetGetPtHardBinFromPath(Bool_t docheck)               { fGetPtHardBinFromName = docheck; }

  void                        SetNumberOfPtHardBins(Int_t nbins)                    { fNPtHardBins = nbins; }

  void                        SetUserPtHardBinning(const TArrayI &binning)          { fPtHardBinning = binning; }

  void                        SetMCLabelShift(Int_t s)                              { fMCLabelShift      = s                              ; }
  void                        SetMinMCLabel(Int_t s)                                { fMinMCLabel        = s                              ; }
  void                        SetMinNTrack(Int_t min)                               { fMinNTrack         = min                            ; }
  void                        SetZvertexDiffValue(Double_t cut)                     { fZvertexDiff  = cut                            ; }
  void                        SetMinPtTrackInEmcal(Double_t min)                    { fMinPtTrackInEmcal = min                            ; }
  virtual void                SetNCentBins(Int_t n)                                 { fNcentBins         = n                              ; }
  void                        SetNeedEmcalGeom(Bool_t n)                            { fNeedEmcalGeom     = n                              ; }
  void                        SetCountDownscaleCorrectedEvents(Bool_t d)            { fCountDownscaleCorrectedEvents =  d                 ; }
  void                        SetOffTrigger(UInt_t t)                               { fOffTrigger        = t                              ; }

  void                        SetTrackEtaLimits(Double_t min, Double_t max, Int_t c=0);

  void                        SetTrackPhiLimits(Double_t min, Double_t max, Int_t c=0);

  void                        SetTrackPtCut(Double_t cut, Int_t c=0);

  void                        SetTrigClass(const char *n)                           { fTrigClass         = n                              ; }
  void                        SetMinBiasTriggerClassName(const char *n)             { fMinBiasRefTrigger = n                              ; }
  void                        SetTriggerTypeSel(TriggerType t)                      { fTriggerTypeSel    = t                              ; } 
  void                        SetUseAliAnaUtils(Bool_t b, Bool_t bRejPilup = kTRUE) { fUseAliAnaUtils    = b ; fRejectPileup = bRejPilup  ; }

  void                        SetUseInternalEventSelection(Bool_t doUse)            { fUseBuiltinEventSelection = doUse                  ; }

  void                        SetUseBuiltinEventSelection(Bool_t doUse)            { fUseBuiltinEventSelection = doUse                  ; }
  
  void                        SetVzRange(Double_t min, Double_t max)                { fMinVz             = min  ; fMaxVz   = max          ; }
  void                        SetMinVertexContrib(Int_t min)                        { fMinVertexContrib = min                             ; }
  void                        SetUseSPDTrackletVsClusterBG(Bool_t b)                { fTklVsClusSPDCut   = b                              ; }
  void                        SetEMCalTriggerMode(EMCalTriggerMode_t m)             { fEMCalTriggerMode  = m                              ; }
  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }
  void                        SetGeneratePythiaInfoObject(Bool_t b)                 { fGeneratePythiaInfoObject = b                       ; }
  void                        SetPythiaInfoName(const char *n)                      { fPythiaInfoName    = n                              ; }
  const TString&              GetPythiaInfoName()                             const { return fPythiaInfoName                              ; }
  const AliEmcalPythiaInfo   *GetPythiaInfo()                                 const { return fPythiaInfo                                  ; }
  void                        SetUsePtHardBinScaling(Bool_t b)                      { fUsePtHardBinScaling = b                            ; }
  void                        SetMCFilter()                                         { fMCRejectFilter = kTRUE                             ; }
  void                        ResetMCFilter()                                       { fMCRejectFilter = kFALSE                            ; }
  void                        SetJetPtFactor(Float_t f)                             { fPtHardAndJetPtFactor = f                           ; }
  Float_t                     JetPtFactor()                                         { return fPtHardAndJetPtFactor                        ; }
  void                        SetClusterPtFactor(Float_t f)                         { fPtHardAndClusterPtFactor = f                       ; }
  Float_t                     ClusterPtFactor()                                     { return fPtHardAndClusterPtFactor                    ; }
  void                        SetTrackPtFactor(Float_t f)                           { fPtHardAndTrackPtFactor = f                         ; }
  Float_t                     TrackPtFactor()                                       { return fPtHardAndTrackPtFactor                      ; }

  // Static Utilities
  static AliAODInputHandler*  AddAODHandler();

  static AliESDInputHandler*  AddESDHandler();

 protected:
  void                        LoadPythiaInfo(AliVEvent *event);

  void                        SetRejectionReasonLabels(TAxis* axis);

  Bool_t                      AcceptCluster(AliVCluster *clus, Int_t c = 0)      const;

  Bool_t                      AcceptTrack(AliVParticle *track, Int_t c = 0)      const;

  void                        AddObjectToEvent(TObject *obj, Bool_t attempt = kFALSE);

  AliVParticle               *GetAcceptParticleFromArray(Int_t p, Int_t c=0)     const;

  AliVCluster                *GetAcceptClusterFromArray(Int_t cl, Int_t c=0)     const;


  TClonesArray               *GetArrayFromEvent(const char *name, const char *clname=0);

  BeamType                    GetBeamType()                                      const;

  TClonesArray               *GetParticleArray(Int_t i=0)                        const;

  TClonesArray               *GetClusterArray(Int_t i=0)                         const;

  Int_t                       GetNParticles(Int_t i=0)                           const;

  Int_t                       GetNClusters(Int_t i=0)                            const;

  AliEMCALTriggerPatchInfo   *GetMainTriggerPatch(TriggerCategory triggersel = kTriggerLevel1Jet, Bool_t doSimpleOffline = kFALSE);

  Bool_t                      HasTriggerType(TriggerType triggersel);

  ULong_t                     GetTriggerList();

  Bool_t                      PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard);
  Bool_t                      IsTrackInEmcalAcceptance(AliVParticle* part, Double_t edges=0.9) const;

  void                        GeneratePythiaInfoObject(AliMCEvent* mcEvent);

  Bool_t                      CheckMCOutliers();

  void                        UserCreateOutputObjects();

  void                        UserExec(Option_t *option);

  Bool_t                      UserNotify();

  Bool_t                      FileChanged();

  virtual void                ExecOnce();

  virtual Bool_t              FillGeneralHistograms();

  virtual Bool_t              IsEventSelected();

  virtual Bool_t              IsTriggerSelected();

  virtual Bool_t              RetrieveEventObjects();

  virtual void                RunChanged(Int_t /*newrun*/)          {}

  virtual void                UserExecOnce()                    {}

  virtual void                UserFileChanged()         {}

  virtual Bool_t              FillHistograms()                  { return kTRUE                 ; }

  virtual Bool_t              Run()                             { return kTRUE                 ; }
    
  // Static utilities
  static void                 GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff);

  static Byte_t               GetTrackType(const AliVTrack *t);

  static Byte_t               GetTrackType(const AliAODTrack *aodTrack, UInt_t filterBit1, UInt_t filterBit2);

  static Double_t             DeltaPhi(Double_t phia, Double_t phib, Double_t rMin = -TMath::Pi()/2, Double_t rMax = 3*TMath::Pi()/2);
  static Double_t*            GenerateFixedBinArray(Int_t n, Double_t min, Double_t max);
  static void                 GenerateFixedBinArray(Int_t n, Double_t min, Double_t max, Double_t* array);

  Bool_t                      IsEventSelectedInternal();

  static Double_t             GetParallelFraction(AliVParticle* part1, AliVParticle* part2);

  static Double_t             GetParallelFraction(const TVector3& vect1, AliVParticle* part2);

  static Double_t             fgkEMCalDCalPhiDivide;       

  // Task configuration
  TString                     fPythiaInfoName;             
  BeamType                    fForceBeamType;              
  Bool_t                      fGeneralHistograms;          
  Bool_t                      fLocalInitialized;           
  Bool_t                      fFileChanged;                
  Bool_t                      fCreateHisto;                
  TString                     fCaloCellsName;              
  TString                     fCaloTriggersName;           
  TString                     fCaloTriggerPatchInfoName;   
  Double_t                    fMinCent;                    
  Double_t                    fMaxCent;                    
  Double_t                    fMinVz;                      
  Double_t                    fMaxVz;                      
  Int_t                       fMinVertexContrib;           
  Double_t                    fTrackPtCut;                 
  Int_t                       fMinNTrack;                  
  Double_t                    fZvertexDiff;                
  Bool_t                      fUseAliAnaUtils;             
  Bool_t                      fRejectPileup;               
  Bool_t                      fTklVsClusSPDCut;            
  UInt_t                      fOffTrigger;                 
  TString                     fTrigClass;                  
  TString                     fMinBiasRefTrigger;          
  TriggerType                 fTriggerTypeSel;             
  Int_t                       fNbins;                      
  Double_t                    fMinBinPt;                   
  Double_t                    fMaxBinPt;                   
  Double_t                    fMinPtTrackInEmcal;          
  Double_t                    fEventPlaneVsEmcal;          
  Double_t                    fMinEventPlane;              
  Double_t                    fMaxEventPlane;              
  TString                     fCentEst;                    
  Bool_t                      fRecycleUnusedEmbeddedEventsMode; 
  Bool_t                      fIsEmbedded;                 
  Bool_t                      fIsPythia;                   
  Bool_t                      fIsHerwig;                   
  Bool_t                      fGetPtHardBinFromName;       
  Int_t                       fSelectPtHardBin;            
  Int_t                       fMinMCLabel;                 
  Int_t                       fMCLabelShift;               
  Int_t                       fNcentBins;                  
  Bool_t                      fNeedEmcalGeom;              
  TObjArray                   fParticleCollArray;          
  TObjArray                   fClusterCollArray;           
  ULong_t                     fTriggers;                   
  EMCalTriggerMode_t          fEMCalTriggerMode;           
  Bool_t                      fUseNewCentralityEstimation; 
  Bool_t                      fGeneratePythiaInfoObject;   
  Bool_t                      fUsePtHardBinScaling;        
  Bool_t                      fUseXsecFromHeader;          
  Bool_t                      fMCRejectFilter;             
  Bool_t                      fCountDownscaleCorrectedEvents; 
  Bool_t                      fUseBuiltinEventSelection;   
  Float_t                     fPtHardAndJetPtFactor;       
  Float_t                     fPtHardAndClusterPtFactor;   
  Float_t                     fPtHardAndTrackPtFactor;     

  // Service fields
  Int_t                       fRunNumber;                  
  AliEventCuts                fAliEventCuts;               
  AliAnalysisUtils           *fAliAnalysisUtils;           
  Bool_t                      fIsEsd;                      
  AliEMCALGeometry           *fGeom;                       
  TClonesArray               *fTracks;                     
  TClonesArray               *fCaloClusters;               
  AliVCaloCells              *fCaloCells;                  
  AliVCaloTrigger            *fCaloTriggers;               
  TClonesArray               *fTriggerPatchInfo;           
  Double_t                    fCent;                       
  Int_t                       fCentBin;                    
  Double_t                    fEPV0;                       
  Double_t                    fEPV0A;                      
  Double_t                    fEPV0C;                      
  Double_t                    fVertex[3];                  
  Double_t                    fVertexSPD[3];               
  Int_t                       fNVertCont;                  
  Int_t                       fNVertSPDCont;               
  BeamType                    fBeamType;                   
  AliGenPythiaEventHeader    *fPythiaHeader;               
  AliGenHerwigEventHeader    *fHerwigHeader;               
  Float_t                     fPtHard;                     
  Int_t                       fPtHardBin;                  
  Int_t                       fPtHardBinGlobal;            
  Bool_t                      fPtHardInitialized;          
  Int_t                       fNPtHardBins;                
  TArrayI                     fPtHardBinning;              
  Int_t                       fNTrials;                    
  Float_t                     fXsection;                   
  AliEmcalPythiaInfo         *fPythiaInfo;                 

  // Output
  AliEmcalList               *fOutput;                     
  TH1                        *fHistEventCount;             
  TH1                        *fHistTrialsAfterSel;         
  TH1                        *fHistEventsAfterSel;         
  TProfile                   *fHistXsectionAfterSel;       
  TH1                        *fHistTrials;                 
  TH1                        *fHistEvents;                 
  TProfile                   *fHistXsection;               
  TH1                        *fHistPtHard;                 
  TH2                        *fHistPtHardCorr;             
  TH2                        *fHistPtHardCorrGlobal;       
  TH2                        *fHistPtHardBinCorr;          
  TH1                        *fHistCentrality;             
  TH1                        *fHistZVertex;                
  TH1                        *fHistEventPlane;             
  TH1                        *fHistEventRejection;         
  TH1                        *fHistTriggerClasses;         
  TH1                        *fHistTriggerClassesCorr;     

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

  ClassDef(AliAnalysisTaskEmcal, 19) // EMCAL base analysis task
};

inline Double_t AliAnalysisTaskEmcal::DeltaPhi(Double_t phia, Double_t phib, Double_t rangeMin, Double_t rangeMax) 
{
  Double_t dphi = -999;
  const Double_t tpi = TMath::TwoPi();
  
  if (phia < 0)         phia += tpi;
  else if (phia > tpi) phia -= tpi;
  if (phib < 0)         phib += tpi;
  else if (phib > tpi) phib -= tpi;
  dphi = phib - phia;
  if (dphi < rangeMin)      dphi += tpi;
  else if (dphi > rangeMax) dphi -= tpi;
  
  return dphi;
}

inline void AliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max, Double_t* array)
{
  Double_t binWidth = (max-min)/n;
  array[0] = min;
  for (Int_t i = 1; i <= n; i++) {
    array[i] = array[i-1]+binWidth;
  }
}

inline Double_t* AliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max)
{
  Double_t *array = new Double_t[n+1];
  GenerateFixedBinArray(n, min, max, array);
  return array;
}

#endif