AliAnalysisTaskDeltaPt.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKDELTAPT_H
#define ALIANALYSISTASKDELTAPT_H

// $Id$

class TClonesArray;
class TString;
class TH1;
class TH2;
class TH3;
class AliJetContainer;
class AliParticleContainer;
class AliClusterContainer;

#include "AliAnalysisTaskEmcalJet.h"

class AliAnalysisTaskDeltaPt : public AliAnalysisTaskEmcalJet {
 public:

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

  void                        UserCreateOutputObjects();

  void                        SetJetMinRC2LJ(Float_t d)                            { fMinRC2LJ                = d          ; }
  void                        SetRCperEvent(Int_t n)                               { fRCperEvent              = n          ; }
  void                        SetMCJetPtThreshold(Double_t t)                      { fMCJetPtThreshold        = t          ; }
  void                        SetConeRadius(Double_t r)                            { fConeRadius              = r          ; }
  void                        SetConeEtaPhiEMCAL() ;
  void                        SetConeEtaPhiTPC()   ;
  void                        SetConeEtaLimits(Float_t min, Float_t max)           { fConeMinEta = min, fConeMaxEta = max  ; }
  void                        SetConePhiLimits(Float_t min, Float_t max)           { fConeMinPhi = min, fConeMaxPhi = max  ; }

 protected:
  void                        AllocateHistogramArrays()                                                                     ;
  void                        ExecOnce()                                                                                    ;
  Bool_t                      FillHistograms()                                                                              ;
  void                        GetLeadingJets(Int_t &maxJetIndex, Int_t &max2JetIndex)                                       ;
  AliEmcalJet*                NextEmbeddedJet(Bool_t reset=kFALSE)                                                          ;
  void                        DoEmbTrackLoop()                                                                              ;
  void                        DoEmbClusterLoop()                                                                            ;
  void                        GetRandomCone(Float_t &pt, Float_t &eta, Float_t &phi, AliParticleContainer* tracks, AliClusterContainer* clusters,
              AliEmcalJet *jet = 0, Bool_t bPartialExclusion = 0) const;
  Double_t                    GetNColl() const;


  Double_t                    fMCJetPtThreshold;           // threshold for MC jets
  Float_t                     fMinRC2LJ;                   // Minimum distance random cone to leading jet
  Int_t                       fRCperEvent;                 // No. of random cones per event
  Double_t                    fConeRadius;                 // Radius of the random cones
  Float_t                     fConeMinEta;                 // Minimum eta of the random cones
  Float_t                     fConeMaxEta;                 // Maximum eta of the random cones
  Float_t                     fConeMinPhi;                 // Minimum phi of the random cones
  Float_t                     fConeMaxPhi;                 // Maximum phi of the random cones

  AliJetContainer            *fJetsCont;                   
  AliParticleContainer       *fTracksCont;                 
  AliClusterContainer        *fCaloClustersCont;           
  AliJetContainer            *fEmbJetsCont;                
  AliParticleContainer       *fEmbTracksCont;              
  AliClusterContainer        *fEmbCaloClustersCont;        
  AliParticleContainer       *fRandTracksCont;             
  AliClusterContainer        *fRandCaloClustersCont;       

  // General
  TH2                        *fHistRhovsCent;              

  // Random cones
  TH2                        *fHistRCPhiEta;               
  TH1                       **fHistRCPt;                   
  TH1                       **fHistRCPtExLJ;               
  TH1                       **fHistRCPtExPartialLJ;        
  TH1                       **fHistRCPtRand;               
  TH2                       **fHistRhoVSRCPt;              
  TH2                       **fHistDeltaPtRCvsEP;          
  TH1                       **fHistDeltaPtRCExLJ;          
  TH1                       **fHistDeltaPtRCExPartialLJ;   
  TH1                       **fHistDeltaPtRCRand;          

  // Jet embedding
  TH3                       **fHistEmbJetsPtArea;          
  TH3                       **fHistEmbJetsCorrPtArea;      
  TH2                       **fHistEmbPartPtvsJetPt;       
  TH2                       **fHistEmbPartPtvsJetCorrPt;   
  TH2                       **fHistJetPtvsJetCorrPt;       
  TH1                       **fHistDistLeadPart2JetAxis;   
  TH2                       **fHistEmbBkgArea;             
  TH2                       **fHistRhoVSEmbBkg;            
  TH2                       **fHistDeltaPtEmbArea;         
  TH2                       **fHistDeltaPtEmbvsEP;         
  TH2                        *fHistRCPtExLJVSDPhiLJ;       
  TH2                        *fHistRCPtExPartialLJVSDPhiLJ;
  TH2                        *fHistEmbJetsPhiEta;          
  TH2                        *fHistLeadPartPhiEta;         

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

  ClassDef(AliAnalysisTaskDeltaPt, 5) // deltaPt analysis task
};
#endif