AliAnalysisTaskEmcalLight.h

Go to the documentation of this file.

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

class TClonesArray;
class TString;
class TList;
class AliEmcalParticle;
class AliMCParticle;
class AliVCluster;
class AliVTrack;
class AliVParticle;
class AliVCaloCells;
class TH1;
class TProfile;
class AliEMCALGeometry;
class AliGenPythiaEventHeader;
class AliVCaloTrigger;
class AliAnalysisUtils;
class AliEMCALTriggerPatchInfo;
class AliAODTrack;

#include <map>
#include <set>
#include <string>

#include "Rtypes.h"

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

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

  enum EDataType_t {
    kUnknownDataType,
    kESD,
    kAOD
  };

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

  AliAnalysisTaskEmcalLight();
  AliAnalysisTaskEmcalLight(const char *name, Bool_t histo=kFALSE);
  virtual ~AliAnalysisTaskEmcalLight();

  // Containers
  AliParticleContainer       *AddParticleContainer(std::string branchName, std::string contName="");
  AliClusterContainer        *AddClusterContainer(std::string branchName, std::string contName="");
  void                        AdoptParticleContainer(AliParticleContainer* cont)    { fParticleCollArray.insert(std::pair<std::string, AliParticleContainer*>(cont->GetName(), cont)); }
  void                        AdoptClusterContainer(AliClusterContainer* cont)      { fClusterCollArray.insert(std::pair<std::string, AliClusterContainer*>(cont->GetName(), cont))  ; }
  AliParticleContainer       *GetParticleContainer(std::string name)          const;
  AliClusterContainer        *GetClusterContainer(std::string name)           const;
  AliMCParticleContainer     *GetMCParticleContainer(std::string name)        const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(name)); }
  AliTrackContainer          *GetTrackContainer(std::string name)             const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(name))     ; }
  void                        RemoveParticleContainer(std::string name)             { fParticleCollArray.erase(name)                      ; }
  void                        RemoveClusterContainer(std::string name)              { fClusterCollArray.erase(name)                       ; }

  // Other input data
  void                        SetCaloCellsName(const char *n)                       { fCaloCellsName     = n                              ; }
  void                        SetCaloTriggerPatchInfoName(const char *n)            { fCaloTriggerPatchInfoName = n                       ; }
  void                        SetCaloTriggersName(const char *n)                    { fCaloTriggersName  = n                              ; }
  void                        SetCentralityEstimator(const char *c)                 { fCentEst           = c                              ; }
  void                        SetIsPythia(Bool_t i)                                 { fIsPythia          = i                              ; }
  void                        SetForceBeamType(EBeamType_t f)                       { fForceBeamType     = f                              ; }

  // Task configuration
  void                        SetUseNewCentralityEstimation(Bool_t b)               { fUseNewCentralityEstimation = b                     ; }
  void                        SetMakeGeneralHistograms(Bool_t g)                    { fGeneralHistograms = g                              ; }
  void                        SetNeedEmcalGeom(Bool_t n)                            { fNeedEmcalGeom     = n                              ; }
  void                        SetCentBins(const std::vector<double>& bins)          { fCentBins = std::vector<double>(bins)               ; }
  Int_t                       GetNCentBins()                                  const { return fCentBins.size() > 1 ? fCentBins.size() - 1 : 1; }
  void                        SetSwitchOffLHC15oFaultyBranches(Bool_t b)            { fSwitchOffLHC15oFaultyBranches = b                  ; }

  // Event selection
  void                        SetTriggerSelectionBitMap(UInt_t t)                   { fTriggerSelectionBitMap = t                         ; }
  void                        SetCentRange(Double_t min, Double_t max)              { fMinCent           = min  ; fMaxCent     = max      ; }
  void                        SetVzRange(Double_t min, Double_t max)                { fMinVz             = min  ; fMaxVz       = max      ; }
  void                        SetZvertexDiffValue(Double_t cut)                     { fMaxVzDiff         = cut                            ; }
  void                        SetMinNVertCont(Int_t cut)                            { fMinNVertCont      = cut                            ; }
  void                        SetPtHardRange(Double_t min, Double_t max)            { fMinPtHard         = min  ; fMaxPtHard   = max      ; }
  void                        SetMaxMinimumBiasPtHard(Int_t max)                    { fMaxMinimumBiasPtHard = max                         ; }
  void                        AddAcceptedTriggerClass(const char* trigClass)        { fAcceptedTriggerClasses.insert(trigClass)           ; }
  void                        AddRejectedTriggerClass(const char* trigClass)        { fRejectedTriggerClasses.insert(trigClass)           ; }
  void                        ClearAcceptedTriggerClasses()                         { fAcceptedTriggerClasses.clear()                     ; }
  void                        ClearRejectedTriggerClasses()                         { fRejectedTriggerClasses.clear()                     ; }
  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                      ; }

 protected:
  void                        SetRejectionReasonLabels(TAxis* axis);
  void                        AddObjectToEvent(TObject *obj, Bool_t attempt = kFALSE);
  TClonesArray               *GetArrayFromEvent(const char *name, const char *clname=0);
  EBeamType_t                 GetBeamType();
  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;
  Bool_t                      CheckMCOutliers();

  // Overloaded AliAnalysisTaskSE methods
  void                        UserCreateOutputObjects();
  void                        UserExec(Option_t *option);
  Bool_t                      UserNotify();

  // Virtual functions, to be overloaded in derived classes
  virtual void                ExecOnce();
  virtual Bool_t              FillGeneralHistograms();
  virtual Bool_t              IsEventSelected();
  virtual Bool_t              RetrieveEventObjects();
  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);
  static Double_t             GetParallelFraction(AliVParticle* part1, AliVParticle* part2);
  static Double_t             GetParallelFraction(const TVector3& vect1, AliVParticle* part2);
  static EBeamType_t          BeamTypeFromRunNumber(Int_t runnumber);

  static Double_t             fgkEMCalDCalPhiDivide;       

  // Task configuration
  EBeamType_t                 fForceBeamType;              
  Bool_t                      fGeneralHistograms;          
  Bool_t                      fCreateHisto;                
  Bool_t                      fNeedEmcalGeom;              
  std::vector<double>         fCentBins;                   
  Bool_t                      fUseNewCentralityEstimation; 

  // Input data
  Bool_t                      fIsPythia;                   
  TString                     fCaloCellsName;              
  TString                     fCaloTriggersName;           
  TString                     fCaloTriggerPatchInfoName;   
  TString                     fCentEst;                    

  std::map<std::string,
  AliParticleContainer*>      fParticleCollArray;          
  std::map<std::string,
  AliClusterContainer*>       fClusterCollArray;          

  // Event selection
  UInt_t                      fTriggerSelectionBitMap;     
  Double_t                    fMinCent;                    
  Double_t                    fMaxCent;                    
  Double_t                    fMinVz;                      
  Double_t                    fMaxVz;                      
  Double_t                    fMaxVzDiff;                  
  Double_t                    fMinNVertCont;               
  Double_t                    fMinPtHard;                  
  Double_t                    fMaxPtHard;                  
  Double_t                    fMaxMinimumBiasPtHard;       
  std::set<std::string>       fAcceptedTriggerClasses;     
  std::set<std::string>       fRejectedTriggerClasses;     
  Bool_t                      fMCRejectFilter;             
  Float_t                     fPtHardAndJetPtFactor;       
  Float_t                     fPtHardAndClusterPtFactor;   
  Float_t                     fPtHardAndTrackPtFactor;     
  Bool_t                      fSwitchOffLHC15oFaultyBranches; 

  // Service fields
  Bool_t                      fLocalInitialized;           
  EDataType_t                 fDataType;                   
  AliEMCALGeometry           *fGeom;                       
  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;               
  ULong_t                     fFiredTriggerBitMap;         
  TString                     fFiredTriggerClasses;        
  EBeamType_t                 fBeamType;                   
  AliGenPythiaEventHeader    *fPythiaHeader;               
  Int_t                       fPtHardBin;                  
  Double_t                    fPtHard;                     
  Int_t                       fNTrials;                    
  Float_t                     fXsection;                   

  // Output
  TList                      *fOutput;                     
  TH1                        *fHistEventCount;             
  TH1                        *fHistTrialsVsPtHard;         
  TH1                        *fHistEventsVsPtHard;         
  TProfile                   *fHistXsectionVsPtHard;       
  TH1                        *fHistTrials;                 
  TH1                        *fHistEvents;                 
  TProfile                   *fHistXsection;               
  TH1                        *fHistCentrality;             
  TH1                        *fHistZVertex;                
  TH1                        *fHistEventPlane;             
  TH1                        *fHistEventRejection;         
  TH1                        *fHistTriggerClasses;         

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

  ClassDef(AliAnalysisTaskEmcalLight, 3);
};

inline Double_t AliAnalysisTaskEmcalLight::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 AliAnalysisTaskEmcalLight::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* AliAnalysisTaskEmcalLight::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