AliAnaParticleJetLeadingConeCorrelation.h

Go to the documentation of this file.

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

//_________________________________________________________________________


// --- ROOT system ---
class TH2F;

//---- Analysis system ----
class AliAODTrack;
class AliVCluster;
class AliCaloTrackReader;
class AliNeutralMesonSelection;

#include "AliAnaCaloTrackCorrBaseClass.h"

class AliAnaParticleJetLeadingConeCorrelation : public AliAnaCaloTrackCorrBaseClass {

public:
  
  AliAnaParticleJetLeadingConeCorrelation() ;
    
  virtual ~AliAnaParticleJetLeadingConeCorrelation() { ; }

  TList *   GetCreateOutputObjects();

  void      InitParameters();
  
  void      Print(const Option_t * opt) const;
  
  Bool_t    AreJetsRecalculated()      const { return fReMakeJet              ; }
  void      SwitchOnJetsRecalculation()      { fReMakeJet = kTRUE             ; }
  void      SwitchOffJetsRecalculation()     { fReMakeJet = kFALSE            ; }
  
  Bool_t    AreJetsOnlyInCTS()         const { return fJetsOnlyInCTS          ; }
  void      SwitchOnJetsOnlyInCTS()          { fJetsOnlyInCTS = kTRUE         ; }
  void      SwitchOffJetsOnlyInCTS()         { fJetsOnlyInCTS = kFALSE        ; }
  
  Bool_t    AreSeveralConeAndPtCuts()  const { return fSeveralConeAndPtCuts   ; }
  void      SwitchOnSeveralConeAndPtCuts()   { fSeveralConeAndPtCuts = kTRUE  ; }
  void      SwitchOffSeveralConeAndPtCuts()  { fSeveralConeAndPtCuts = kFALSE ; }
  
  Bool_t    IsPbPb()                   const { return fPbPb                   ; }
  void      SetppCollisions()                { fPbPb = kFALSE                 ; }
  void      SetPbPbCollisions()              { fPbPb = kTRUE                  ; }
  
  Double_t  GetDeltaPhiMaxCut()        const { return fDeltaPhiMaxCut         ; }
  Double_t  GetDeltaPhiMinCut()        const { return fDeltaPhiMinCut         ; }
  Double_t  GetLeadingRatioMaxCut()    const { return fLeadingRatioMaxCut     ; }
  Double_t  GetLeadingRatioMinCut()    const { return fLeadingRatioMinCut     ; }
  
  Double_t  GetPtTriggerSelectionCut() const { return fPtTriggerSelectionCut  ; }
  Double_t  GetJetRatioMaxCut()        const { return fJetRatioMaxCut         ; }
  Double_t  GetJetRatioMinCut()        const { return fJetRatioMinCut         ; }

  void      SetPtTriggerSelectionCut(Double_t cut)
                                             { fPtTriggerSelectionCut = cut   ; }
  void      SetJetSelectionMode(UInt_t sel)  { fSelect= sel                   ; }
  
  Int_t     GetJetNCones()             const { return fJetNCone               ; }
  Int_t     GetJetNPtThres()           const { return fJetNPt                 ; }
  Float_t   GetJetCone()               const { return fJetCone                ; }
  Float_t   GetJetPtThreshold()        const { return fJetPtThreshold         ; }
  Float_t   GetJetPtThresPbPb()        const { return fJetPtThresPbPb         ; }
  Float_t   GetJetCones(Int_t i)       const { return fJetCones[i]            ; }
  Float_t   GetJetPtThreshold(Int_t i) const { return fJetPtThres[i]          ; }
  TString   GetJetConeName(Int_t i)    const { return fJetNameCones[i]        ; }
  TString   GetJetPtThresName(Int_t i) const { return fJetNamePtThres[i]      ; }
  

  void      SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
                                             { fDeltaPhiMaxCut =phimax;  fDeltaPhiMinCut =phimin;}
  void      SetLeadingRatioCutRange(Double_t ratiomin, Double_t ratiomax)
                                             { fLeadingRatioMaxCut =ratiomax;  fLeadingRatioMinCut = ratiomin ; }

  void      SetJetNCones(Int_t n)            { fJetNCone = n                 ; }
  void      SetJetNPtThresholds(Int_t n)     { fJetNPt   = n                 ; }
  void      SetJetCones(Int_t i, Float_t cone, TString sc)
                                             { fJetCones[i] = cone ; fJetNameCones[i]   = sc  ; }
  void      SetCone(Float_t cone)            { fJetCone        = cone        ; }
  void      SetJetPtThreshold(Float_t pt)    { fJetPtThreshold = pt          ; }
  void      SetJetPtThresPbPb(Float_t pt)    { fJetPtThresPbPb = pt          ; }
  void      SetJetPtThresholds(Int_t i,Float_t pt, TString spt)
                                             { fJetPtThres[i] = pt ; fJetNamePtThres[i] = spt ; }
  
  void      SetJetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
                                             { fJetRatioMaxCut    = ratiomax ;  fJetRatioMinCut    = ratiomin ; }
  void      SetJetCTSRatioCutRange(Double_t ratiomin, Double_t ratiomax)
                                             { fJetCTSRatioMaxCut = ratiomax ;  fJetCTSRatioMinCut = ratiomin ; }
  
  Bool_t    OnlyIsolated()             const { return fSelectIsolated        ; }
  void      SelectIsolated(Bool_t select)    { fSelectIsolated = select      ; }
    
 private:
  
  Double_t  CalculateJetRatioLimit(Double_t ptTrig, const Double_t *param, const Double_t *x) const ;
  
  void      FillJetHistos(AliCaloTrackParticleCorrelation * particle, const TLorentzVector jet,
                          const TString & type, const TString & lastname);
  
  TList *   GetOutputContainer()       const { return fOutCont               ; }
  
  Bool_t    IsJetSelected(Double_t ptTrig, Double_t ptjet) const ;
  Bool_t    IsParticleInJetCone(Double_t eta, Double_t phi, Double_t etal, Double_t phil) const ;
  
  void      GetLeadingCharge  (AliCaloTrackParticleCorrelation * particle) ;
  void      GetLeadingPi0     (AliCaloTrackParticleCorrelation * particle) ;
  Bool_t    GetLeadingParticle(AliCaloTrackParticleCorrelation * particle) ;
  
  void      MakeAnalysisFillAOD();
  void      MakeAnalysisFillHistograms();
  void      MakeAODJet(AliCaloTrackParticleCorrelation * particle) ;
  void      MakeJetFromAOD(AliCaloTrackParticleCorrelation * particle) ;
  
  Bool_t    SelectCluster(AliVCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
  
 private:
  
  Bool_t     fJetsOnlyInCTS ;                 
  Bool_t     fPbPb;                           
  Bool_t     fSeveralConeAndPtCuts;           
  Bool_t     fReMakeJet ;                     

  // Leading particle selection parameters
  Double_t   fDeltaPhiMaxCut ;                
  Double_t   fDeltaPhiMinCut ;                
  Double_t   fLeadingRatioMaxCut ;            
  Double_t   fLeadingRatioMinCut ;            

  // Jet selection parameters
  // Fixed cuts (old)
  Double_t   fJetCTSRatioMaxCut ;             
  Double_t   fJetCTSRatioMinCut ;             
  Double_t   fJetRatioMaxCut ;                
  Double_t   fJetRatioMinCut ;                
  
  // Cuts depending on jet pt
  Double_t   fJetE1[2];                       
  Double_t   fJetE2[2];                       
  Double_t   fJetSigma1[2];                   
  Double_t   fJetSigma2[2];                   
  Double_t   fBkgMean[6];                     
  Double_t   fBkgRMS[6];                      
  Double_t   fJetXMin1[6];                    
  Double_t   fJetXMin2[6];                    
  Double_t   fJetXMax1[6];                    
  Double_t   fJetXMax2[6];                    
  
  Int_t      fJetNCone ;                      
  Int_t      fJetNPt   ;                      
  Double_t   fJetCone  ;                      
  Double_t   fJetCones[5];                    
  TString    fJetNameCones[5];                
  Double_t   fJetPtThreshold;                 
  Double_t   fJetPtThresPbPb;                 
  Double_t   fJetPtThres[5];                  
  TString    fJetNamePtThres[5];              
  Double_t   fPtTriggerSelectionCut;          
  UInt_t     fSelect  ;                       
  Bool_t     fSelectIsolated ;                

  // Temporary kinematic containers
  TVector3       fTrackVector;                
  TLorentzVector fBkgMom;                     
  TLorentzVector fJetMom;                     
  TLorentzVector fJetConstMom;                
  TLorentzVector fLeadingMom;                 
  TLorentzVector fLeadingPi0Mom;              
  TLorentzVector fLeadingPhoMom1;             
  TLorentzVector fLeadingPhoMom2;             
  TLorentzVector fLeadingChargeMom;           
  
  // Histograms
  // Leading particle distributions
  TList *  fOutCont ;                          

  TH2F * fhChargedLeadingPt   ;                
  TH2F * fhChargedLeadingPhi  ;                
  TH2F * fhChargedLeadingEta  ;                
  TH2F * fhChargedLeadingDeltaPt  ;            
  TH2F * fhChargedLeadingDeltaPhi ;            
  TH2F * fhChargedLeadingDeltaEta ;            
  TH2F * fhChargedLeadingRatioPt  ;            

  TH2F * fhNeutralLeadingPt    ;               
  TH2F * fhNeutralLeadingPhi   ;               
  TH2F * fhNeutralLeadingEta   ;               
  TH2F * fhNeutralLeadingDeltaPt   ;           
  TH2F * fhNeutralLeadingDeltaPhi  ;           
  TH2F * fhNeutralLeadingDeltaEta  ;           
  TH2F * fhNeutralLeadingRatioPt   ;           
  TH2F * fhChargedLeadingXi  ;                 
  TH2F * fhNeutralLeadingXi  ;                 
  
  TH2F * fhChargedLeadingDeltaPhiRatioPt30  ;  
  TH2F * fhNeutralLeadingDeltaPhiRatioPt30  ;  
  TH2F * fhChargedLeadingDeltaPhiRatioPt50  ;  
  TH2F * fhNeutralLeadingDeltaPhiRatioPt50  ;  
  
  // Jet distributions
  // Fixed cone and pt threshold
  TH2F * fhJetPt  ;                            
  TH2F * fhJetRatioPt  ;                       
  TH2F * fhJetDeltaPhi  ;                      
  TH2F * fhJetDeltaEta  ;                      
  TH2F * fhJetLeadingRatioPt  ;                
  TH2F * fhJetLeadingDeltaPhi  ;               
  TH2F * fhJetLeadingDeltaEta  ;               
  TH2F * fhJetFFz;                             
  TH2F * fhJetFFxi;                            
  TH2F * fhJetFFpt;                            
  TH2F * fhJetNTracksInCone   ;                

  TH2F * fhBkgPt  ;                            
  TH2F * fhBkgRatioPt  ;                       
  TH2F * fhBkgDeltaPhi  ;                      
  TH2F * fhBkgDeltaEta  ;                      
  TH2F * fhBkgLeadingRatioPt  ;                
  TH2F * fhBkgLeadingDeltaPhi  ;               
  TH2F * fhBkgLeadingDeltaEta  ;               
  TH2F * fhBkgFFz;                             
  TH2F * fhBkgFFxi;                            
  TH2F * fhBkgFFpt;                            
  TH2F * fhBkgNTracksInCone   ;                

  // Variable cone and pt threshold

  TH2F * fhJetPts      [5][5];                 
  TH2F * fhJetRatioPts [5][5];                 
  TH2F * fhJetDeltaPhis[5][5];                 
  TH2F * fhJetDeltaEtas[5][5];                 
  TH2F * fhJetLeadingRatioPts [5][5];          
  TH2F * fhJetLeadingDeltaPhis[5][5];          
  TH2F * fhJetLeadingDeltaEtas[5][5];          
  TH2F * fhJetFFzs [5][5];                     
  TH2F * fhJetFFxis[5][5];                     
  TH2F * fhJetFFpts[5][5];                     
  TH2F * fhJetNTracksInCones[5][5];            

  TH2F * fhBkgPts      [5][5];                 
  TH2F * fhBkgRatioPts [5][5];                 
  TH2F * fhBkgDeltaPhis[5][5];                 
  TH2F * fhBkgDeltaEtas[5][5];                 
  TH2F * fhBkgLeadingRatioPts [5][5];          
  TH2F * fhBkgLeadingDeltaPhis[5][5];          
  TH2F * fhBkgLeadingDeltaEtas[5][5];          
  TH2F * fhBkgFFzs [5][5];                     
  TH2F * fhBkgFFxis[5][5];                     
  TH2F * fhBkgFFpts[5][5];                     
  TH2F * fhBkgNTracksInCones[5][5];            
  
  AliAnaParticleJetLeadingConeCorrelation              (const AliAnaParticleJetLeadingConeCorrelation & g) ;
    
  AliAnaParticleJetLeadingConeCorrelation & operator = (const AliAnaParticleJetLeadingConeCorrelation & g) ;
  
  ClassDef(AliAnaParticleJetLeadingConeCorrelation,2) ;
 
} ;

#endif //ALIANAPARTICLEJETLEADINGCONECORRELATION_H