[u/mrichter/AliRoot.git] / PWG4 / PartCorrDep / AliAnaParticleJetLeadingConeCorrelation.h

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

//_________________________________________________________________________
// Class that contains the algorithm for the reconstruction of jet, cone around leading particle
// The seed is a backward particle (direct photon)
// 1)Take the a trigger particle found stored in AliAODPWG4ParticleCorrelation,
// 2) Search for the highest pt leading particle opposite to the trigger within a phi, pt window
// 3) Take all particles around leading in a cone R with pt larger than threshold and construct the jet
//
//  Class created from old AliPHOSGammaJet
//  (see AliRoot versions previous Release 4-09)
//
//-- Author: Gustavo Conesa (INFN-LNF)

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

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

#include "AliAnaPartCorrBaseClass.h"

class AliAnaParticleJetLeadingConeCorrelation : public AliAnaPartCorrBaseClass {

public: 
  
  AliAnaParticleJetLeadingConeCorrelation() ; // default ctor
  AliAnaParticleJetLeadingConeCorrelation(const AliAnaParticleJetLeadingConeCorrelation & g) ; // cpy ctor
  AliAnaParticleJetLeadingConeCorrelation & operator = (const AliAnaParticleJetLeadingConeCorrelation & g) ;//cpy assignment
  virtual ~AliAnaParticleJetLeadingConeCorrelation() ; //virtual dtor
  
  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 select){ fSelect= select ; }
  
  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(const Double_t ptTrig, const Double_t *param, const Double_t *x) const ;
  
  void FillJetHistos(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector  leading, const TLorentzVector jet, const TString type, const TString lastname);
  
  TList * GetOutputContainer() const {return fOutCont; }
  
  Bool_t IsJetSelected(const Double_t ptTrig, const Double_t ptjet) const ;
  Bool_t IsParticleInJetCone(const Double_t eta, Double_t phi, const Double_t etal, Double_t phil) const ;
  
  void GetLeadingCharge(AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading) const ;
  void GetLeadingPi0   (AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading)  const ;
  Bool_t GetLeadingParticle(AliAODPWG4ParticleCorrelation *particle, TLorentzVector &  pLeading) const ;
  
  void MakeAnalysisFillAOD();
  void MakeAnalysisFillHistograms();   
  void MakeAODJet(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector pLeading) const ; 
  void MakeJetFromAOD(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector pLeading, 
		      TLorentzVector & jet, TLorentzVector & bkg) const ; 
  
  Bool_t  SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) const ;
  
 private:
  
  Bool_t     fJetsOnlyInCTS ;    // Jets measured only in TPC+ITS.
  Bool_t     fPbPb;          // PbPb event
  Bool_t     fSeveralConeAndPtCuts;     //  To play with the jet cone size and pt th.
  Bool_t     fReMakeJet ; //Re make the jet reconstruction from AODParticleCorrelation input

  //Leading particle selection parameters  
  Double_t   fDeltaPhiMaxCut ;      // Minimum Delta Phi Gamma-Leading
  Double_t   fDeltaPhiMinCut ;      //  Maximum Delta Phi Gamma-Leading
  Double_t   fLeadingRatioMaxCut ; // Leading /gamma Ratio cut maximum
  Double_t   fLeadingRatioMinCut ; // Leading/gamma Ratio cut minimum

  //Jet selection parameters
  //Fixed cuts (old)
  Double_t   fJetCTSRatioMaxCut ; // Jet(CTS) /gamma Ratio cut maximum
  Double_t   fJetCTSRatioMinCut ; // Jet(CTS) /gamma Ratio cut maximum
  Double_t   fJetRatioMaxCut ; // Jet(EMCAL+CTS)/gamma Ratio cut maximum
  Double_t   fJetRatioMinCut ; // Jet(EMCAL+CTS)/gamma Ratio cut minimum
  
  //Cuts depending on jet pt
  Double_t   fJetE1[2];    //Rec. jet energy parameters
  Double_t   fJetE2[2];    //Rec. jet energy parameters
  Double_t   fJetSigma1[2];//Rec. sigma of jet energy  parameters
  Double_t   fJetSigma2[2];//Rec. sigma of jet energy  parameters
  Double_t   fBkgMean[6];  //Background mean energy 
  Double_t   fBkgRMS[6];   //Background RMS
  Double_t   fJetXMin1[6]; //X Factor to set jet min limit for pp
  Double_t   fJetXMin2[6]; //X Factor to set jet min limit for PbPb
  Double_t   fJetXMax1[6]; //X Factor to set jet max limit for pp
  Double_t   fJetXMax2[6]; //X Factor to set jet max limit for PbPb
  
  Int_t      fJetNCone ;            // Number of jet cones sizes, maximum 5
  Int_t      fJetNPt   ;            // Number of jet particle pT threshold, maximum 5
  Double_t   fJetCone  ;            // Jet cone sizes under study (!fSeveralConeAndPtCuts)
  Double_t   fJetCones[5];         // Jet cone sizes under study (fSeveralConeAndPtCuts)
  TString    fJetNameCones[5];     // String name of cone to append to histos
  Double_t   fJetPtThreshold;       // Jet pT threshold under study(!fSeveralConeAndPtCuts)
  Double_t   fJetPtThresPbPb;       // Jet pT threshold under study(!fSeveralConeAndPtCuts)
  Double_t   fJetPtThres[5];       // Jet pT threshold under study(fSeveralConeAndPtCuts)
  TString    fJetNamePtThres[5];   // String name of pt th to append to histos
  Double_t   fPtTriggerSelectionCut; // Jet pt to change to low pt jets analysis
  UInt_t     fSelect  ;   //kTRUE: Selects all jets, no limits.
  Bool_t     fSelectIsolated ;      // Select only trigger particles isolated

  //Histograms
  //Leading particle distributions
  TList *  fOutCont ; //! Container for histograms

  TH2F * fhChargedLeadingPt  ;    //! Pt(Pt trigger) distribution of charged hadrons
  TH2F * fhChargedLeadingPhi  ;   //! Phi(Pt trigger) distribution of charged hadrons
  TH2F * fhChargedLeadingEta  ;   //! Eta(Pt trigger) distribution of charged hadrons
  TH2F * fhChargedLeadingDeltaPt  ;   //! Difference of charged hadron and trigger  pT as function of trigger p
  TH2F * fhChargedLeadingDeltaPhi  ;  //! Difference of charged hadron and trigger  phi as function of trigger pT
  TH2F * fhChargedLeadingDeltaEta ;   //! Difference of charged particle and trigger eta as function of trigger pT
  TH2F * fhChargedLeadingRatioPt  ; //! Ratio of Pt leading charge and trigger

  TH2F * fhNeutralLeadingPt   ;   //! Pt(Pt trigger) distribution of neutral hadrons
  TH2F * fhNeutralLeadingPhi   ;  //! Phi(Pt trigger) distribution of neutral hadrons
  TH2F * fhNeutralLeadingEta   ;  //! Eta(Pt trigger) distribution of neutral hadrons
  TH2F * fhNeutralLeadingDeltaPt   ;  //! Difference of neutral hadron and trigger pT as function of trigger pT
  TH2F * fhNeutralLeadingDeltaPhi  ;  //! Difference of neutral hadron and trigger phi as function of trigger pT
  TH2F * fhNeutralLeadingDeltaEta ;   //! Difference of charged particle and trigger eta as function of trigger pT
  TH2F * fhNeutralLeadingRatioPt   ;  //! Ratio of Pt leading neutral and trigger
	
  TH2F * fhChargedLeadingXi  ;   //! Ln (pt leading charge / pt trigger)
  TH2F * fhNeutralLeadingXi  ;   //! Ln (pt leading neutral / pt trigger)
	
  TH2F * fhChargedLeadingDeltaPhiRatioPt30  ;  //! Difference of charged hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
  TH2F * fhNeutralLeadingDeltaPhiRatioPt30  ;  //! Difference of neutral hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
  TH2F * fhChargedLeadingDeltaPhiRatioPt50  ;  //! Difference of charged hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
  TH2F * fhNeutralLeadingDeltaPhiRatioPt50  ;  //! Difference of neutral hadron and trigger  phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
	
  // Jet distributions
  // Fixed cone and pt threshold
  TH2F * fhJetPt  ; //! leading pt jet vs pt trigger
  TH2F * fhJetRatioPt  ; //! Ratio of pt jet and pt trigger
  TH2F * fhJetDeltaPhi  ; //! Delta phi jet-trigger
  TH2F * fhJetDeltaEta  ; //! Delta eta jet-trigger
  TH2F * fhJetLeadingRatioPt  ; //! Ratio of pt leading and pt jet
  TH2F * fhJetLeadingDeltaPhi  ; //! Delta phi jet-leading
  TH2F * fhJetLeadingDeltaEta  ; //! Delta eta jet-leading
  TH2F * fhJetFFz; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
  TH2F * fhJetFFxi; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
  TH2F * fhJetFFpt; //! Jet particle pt distribution in cone
  TH2F * fhJetNTracksInCone   ; //! jet multiplicity in cone

  TH2F * fhBkgPt  ; //! leading pt bakground vs pt trigger
  TH2F * fhBkgRatioPt  ; //! Ratio of pt background and pt trigger
  TH2F * fhBkgDeltaPhi  ; //! Delta phi background-trigger
  TH2F * fhBkgDeltaEta  ; //! Delta eta background-trigger
  TH2F * fhBkgLeadingRatioPt  ; //! Ratio of pt leading and pt background
  TH2F * fhBkgLeadingDeltaPhi  ; //! Delta phi background-leading
  TH2F * fhBkgLeadingDeltaEta  ; //! Delta eta background-leading
  TH2F * fhBkgFFz; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
  TH2F * fhBkgFFxi; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
  TH2F * fhBkgFFpt; //! Background particle pt distribution in cone
  TH2F * fhBkgNTracksInCone   ; //! Background multiplicity in cone

  // Variable cone and pt threshold

  TH2F * fhJetPts[5][5]; //! leading pt jet vs pt trigger
  TH2F * fhJetRatioPts[5][5]; //! Ratio of pt jet and pt trigger
  TH2F * fhJetDeltaPhis[5][5]; //! Delta phi jet-trigger
  TH2F * fhJetDeltaEtas[5][5]; //! Delta eta jet-trigger
  TH2F * fhJetLeadingRatioPts[5][5]; //! Ratio of pt leading and pt jet
  TH2F * fhJetLeadingDeltaPhis[5][5]; //! Delta phi jet-leading
  TH2F * fhJetLeadingDeltaEtas[5][5]; //! Delta eta jet-leading
  TH2F * fhJetFFzs[5][5]; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
  TH2F * fhJetFFxis[5][5]; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
  TH2F * fhJetFFpts[5][5]; //! Jet particle pt distribution in cone
  TH2F * fhJetNTracksInCones[5][5]; //! jet multiplicity in cone

  TH2F * fhBkgPts[5][5]; //! leading pt bakground vs pt trigger
  TH2F * fhBkgRatioPts[5][5]; //! Ratio of pt background and pt trigger
  TH2F * fhBkgDeltaPhis[5][5]; //! Delta phi background-trigger
  TH2F * fhBkgDeltaEtas[5][5]; //! Delta eta background-trigger
  TH2F * fhBkgLeadingRatioPts[5][5]; //! Ratio of pt leading and pt background
  TH2F * fhBkgLeadingDeltaPhis[5][5]; //! Delta phi background-leading
  TH2F * fhBkgLeadingDeltaEtas[5][5]; //! Delta eta background-leading
  TH2F * fhBkgFFzs[5][5]; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
  TH2F * fhBkgFFxis[5][5]; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
  TH2F * fhBkgFFpts[5][5]; //! Background particle pt distribution in cone
  TH2F * fhBkgNTracksInCones[5][5]; //! Background multiplicity in cone
  
  
  ClassDef(AliAnaParticleJetLeadingConeCorrelation,1)
 } ;
 

#endif //ALIANAPARTICLEJETLEADINGCONECORRELATION_H
Commit	Line	Data
1c5acb87	1	#ifndef ALIANAPARTICLEJETLEADINGCONECORRELATION_H
	2	#define ALIANAPARTICLEJETLEADINGCONECORRELATION_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5	/* $Id: $ */
	6
	7	//_________________________________________________________________________
	8	// Class that contains the algorithm for the reconstruction of jet, cone around leading particle
	9	// The seed is a backward particle (direct photon)
	10	// 1)Take the a trigger particle found stored in AliAODPWG4ParticleCorrelation,
	11	// 2) Search for the highest pt leading particle opposite to the trigger within a phi, pt window
	12	// 3) Take all particles around leading in a cone R with pt larger than threshold and construct the jet
	13	//
	14	// Class created from old AliPHOSGammaJet
	15	// (see AliRoot versions previous Release 4-09)
	16	//
	17	//-- Author: Gustavo Conesa (INFN-LNF)
	18
	19	// --- ROOT system ---
	20	class TH2F;
	21
	22	//---- Analysis system ----
	23	class AliAODTrack;
	24	class AliAODCaloCluster;
	25	class AliCaloTrackReader;
	26	class AliNeutralMesonSelection;
1c5acb87	27
	28	#include "AliAnaPartCorrBaseClass.h"
	29
	30	class AliAnaParticleJetLeadingConeCorrelation : public AliAnaPartCorrBaseClass {
	31
	32	public:
	33
	34	AliAnaParticleJetLeadingConeCorrelation() ; // default ctor
	35	AliAnaParticleJetLeadingConeCorrelation(const AliAnaParticleJetLeadingConeCorrelation & g) ; // cpy ctor
	36	AliAnaParticleJetLeadingConeCorrelation & operator = (const AliAnaParticleJetLeadingConeCorrelation & g) ;//cpy assignment
	37	virtual ~AliAnaParticleJetLeadingConeCorrelation() ; //virtual dtor
	38
	39	TList * GetCreateOutputObjects();
	40
	41	void InitParameters();
	42
	43	void Print(const Option_t * opt) const;
	44
	45	Bool_t AreJetsRecalculated() const {return fReMakeJet ; }
	46	void SwitchOnJetsRecalculation(){fReMakeJet = kTRUE; }
	47	void SwitchOffJetsRecalculation(){fReMakeJet = kFALSE; }
	48
	49	Bool_t AreJetsOnlyInCTS() const {return fJetsOnlyInCTS ; }
	50	void SwitchOnJetsOnlyInCTS(){fJetsOnlyInCTS = kTRUE; }
	51	void SwitchOffJetsOnlyInCTS(){fJetsOnlyInCTS = kFALSE; }
	52
	53	Bool_t AreSeveralConeAndPtCuts() const {return fSeveralConeAndPtCuts ; }
	54	void SwitchOnSeveralConeAndPtCuts(){fSeveralConeAndPtCuts = kTRUE ;}
	55	void SwitchOffSeveralConeAndPtCuts(){fSeveralConeAndPtCuts = kFALSE ;}
	56
	57	Bool_t IsPbPb() const {return fPbPb ; }
	58	void SetppCollisions(){fPbPb = kFALSE; }
	59	void SetPbPbCollisions(){fPbPb = kTRUE; }
	60
	61	Double_t GetDeltaPhiMaxCut() const {return fDeltaPhiMaxCut ; }
	62	Double_t GetDeltaPhiMinCut() const {return fDeltaPhiMinCut ; }
	63	Double_t GetLeadingRatioMaxCut() const {return fLeadingRatioMaxCut ; }
	64	Double_t GetLeadingRatioMinCut() const {return fLeadingRatioMinCut ; }
	65
	66	Double_t GetPtTriggerSelectionCut() const {return fPtTriggerSelectionCut ; }
	67	Double_t GetJetRatioMaxCut() const {return fJetRatioMaxCut ; }
	68	Double_t GetJetRatioMinCut() const {return fJetRatioMinCut ; }
	69
	70	void SetPtTriggerSelectionCut(Double_t cut){fPtTriggerSelectionCut = cut; }
	71	void SetJetSelectionMode(UInt_t select){ fSelect= select ; }
	72
	73	Int_t GetJetNCones() const {return fJetNCone ; }
	74	Int_t GetJetNPtThres() const {return fJetNPt ; }
	75	Float_t GetJetCone() const {return fJetCone ; }
	76	Float_t GetJetPtThreshold() const {return fJetPtThreshold ; }
	77	Float_t GetJetPtThresPbPb() const {return fJetPtThresPbPb ; }
	78	Float_t GetJetCones(Int_t i) const {return fJetCones[i] ; }
	79	Float_t GetJetPtThreshold(Int_t i) const {return fJetPtThres[i] ; }
	80	TString GetJetConeName(Int_t i) const {return fJetNameCones[i] ; }
	81	TString GetJetPtThresName(Int_t i) const {return fJetNamePtThres[i] ; }
	82
	83
	84	void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
	85	{fDeltaPhiMaxCut =phimax; fDeltaPhiMinCut =phimin;}
	86	void SetLeadingRatioCutRange(Double_t ratiomin, Double_t ratiomax)
	87	{fLeadingRatioMaxCut =ratiomax; fLeadingRatioMinCut = ratiomin ; }
	88
	89	void SetJetNCones(Int_t n){fJetNCone = n ; }
	90	void SetJetNPtThresholds(Int_t n){fJetNPt = n ; }
91	void SetJetCones(Int_t i, Float_t cone, TString sc) {fJetCones[i] = cone ; fJetNameCones[i] = sc; };
92	void SetCone(Float_t cone) {fJetCone = cone; }
93	void SetJetPtThreshold(Float_t pt){fJetPtThreshold = pt; };
94	void SetJetPtThresPbPb(Float_t pt){fJetPtThresPbPb = pt; };
95	void SetJetPtThresholds(Int_t i,Float_t pt, TString spt){fJetPtThres[i] = pt ; fJetNamePtThres[i] = spt; };
96
97	void SetJetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
98	{fJetRatioMaxCut =ratiomax; fJetRatioMinCut = ratiomin ; }
99	void SetJetCTSRatioCutRange(Double_t ratiomin, Double_t ratiomax)
100	{fJetCTSRatioMaxCut =ratiomax; fJetCTSRatioMinCut = ratiomin ; }
101
477d6cee	102	Bool_t OnlyIsolated() const {return fSelectIsolated ; }
	103	void SelectIsolated(Bool_t select) {fSelectIsolated = select ; }
	104
1c5acb87	105	private:
	106
	107	Double_t CalculateJetRatioLimit(const Double_t ptTrig, const Double_t param, const Double_t x) const ;
	108
	109	void FillJetHistos(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector leading, const TLorentzVector jet, const TString type, const TString lastname);
	110
	111	TList * GetOutputContainer() const {return fOutCont; }
	112
	113	Bool_t IsJetSelected(const Double_t ptTrig, const Double_t ptjet) const ;
	114	Bool_t IsParticleInJetCone(const Double_t eta, Double_t phi, const Double_t etal, Double_t phil) const ;
	115
	116	void GetLeadingCharge(AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading) const ;
	117	void GetLeadingPi0 (AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading) const ;
	118	Bool_t GetLeadingParticle(AliAODPWG4ParticleCorrelation *particle, TLorentzVector & pLeading) const ;
	119
	120	void MakeAnalysisFillAOD();
	121	void MakeAnalysisFillHistograms();
	122	void MakeAODJet(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector pLeading) const ;
	123	void MakeJetFromAOD(AliAODPWG4ParticleCorrelation * particle, const TLorentzVector pLeading,
	124	TLorentzVector & jet, TLorentzVector & bkg) const ;
	125
	126	Bool_t SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) const ;
	127
	128	private:
	129
	130	Bool_t fJetsOnlyInCTS ; // Jets measured only in TPC+ITS.
	131	Bool_t fPbPb; // PbPb event
	132	Bool_t fSeveralConeAndPtCuts; // To play with the jet cone size and pt th.
	133	Bool_t fReMakeJet ; //Re make the jet reconstruction from AODParticleCorrelation input
	134
	135	//Leading particle selection parameters
	136	Double_t fDeltaPhiMaxCut ; // Minimum Delta Phi Gamma-Leading
	137	Double_t fDeltaPhiMinCut ; // Maximum Delta Phi Gamma-Leading
	138	Double_t fLeadingRatioMaxCut ; // Leading /gamma Ratio cut maximum
	139	Double_t fLeadingRatioMinCut ; // Leading/gamma Ratio cut minimum
	140
	141	//Jet selection parameters
	142	//Fixed cuts (old)
	143	Double_t fJetCTSRatioMaxCut ; // Jet(CTS) /gamma Ratio cut maximum
	144	Double_t fJetCTSRatioMinCut ; // Jet(CTS) /gamma Ratio cut maximum
	145	Double_t fJetRatioMaxCut ; // Jet(EMCAL+CTS)/gamma Ratio cut maximum
	146	Double_t fJetRatioMinCut ; // Jet(EMCAL+CTS)/gamma Ratio cut minimum
	147
	148	//Cuts depending on jet pt
	149	Double_t fJetE1[2]; //Rec. jet energy parameters
	150	Double_t fJetE2[2]; //Rec. jet energy parameters
	151	Double_t fJetSigma1[2];//Rec. sigma of jet energy parameters
	152	Double_t fJetSigma2[2];//Rec. sigma of jet energy parameters
	153	Double_t fBkgMean[6]; //Background mean energy
	154	Double_t fBkgRMS[6]; //Background RMS
	155	Double_t fJetXMin1[6]; //X Factor to set jet min limit for pp
	156	Double_t fJetXMin2[6]; //X Factor to set jet min limit for PbPb
	157	Double_t fJetXMax1[6]; //X Factor to set jet max limit for pp
	158	Double_t fJetXMax2[6]; //X Factor to set jet max limit for PbPb
	159
	160	Int_t fJetNCone ; // Number of jet cones sizes, maximum 5
	161	Int_t fJetNPt ; // Number of jet particle pT threshold, maximum 5
	162	Double_t fJetCone ; // Jet cone sizes under study (!fSeveralConeAndPtCuts)
	163	Double_t fJetCones[5]; // Jet cone sizes under study (fSeveralConeAndPtCuts)
	164	TString fJetNameCones[5]; // String name of cone to append to histos
	165	Double_t fJetPtThreshold; // Jet pT threshold under study(!fSeveralConeAndPtCuts)
	166	Double_t fJetPtThresPbPb; // Jet pT threshold under study(!fSeveralConeAndPtCuts)
	167	Double_t fJetPtThres[5]; // Jet pT threshold under study(fSeveralConeAndPtCuts)
	168	TString fJetNamePtThres[5]; // String name of pt th to append to histos
169	Double_t fPtTriggerSelectionCut; // Jet pt to change to low pt jets analysis
170	UInt_t fSelect ; //kTRUE: Selects all jets, no limits.
477d6cee	171	Bool_t fSelectIsolated ; // Select only trigger particles isolated
477d6cee	172
1c5acb87	173	//Histograms
	174	//Leading particle distributions
	175	TList * fOutCont ; //! Container for histograms
	176
	177	TH2F * fhChargedLeadingPt ; //! Pt(Pt trigger) distribution of charged hadrons
	178	TH2F * fhChargedLeadingPhi ; //! Phi(Pt trigger) distribution of charged hadrons
	179	TH2F * fhChargedLeadingEta ; //! Eta(Pt trigger) distribution of charged hadrons
	180	TH2F * fhChargedLeadingDeltaPt ; //! Difference of charged hadron and trigger pT as function of trigger p
	181	TH2F * fhChargedLeadingDeltaPhi ; //! Difference of charged hadron and trigger phi as function of trigger pT
	182	TH2F * fhChargedLeadingDeltaEta ; //! Difference of charged particle and trigger eta as function of trigger pT
	183	TH2F * fhChargedLeadingRatioPt ; //! Ratio of Pt leading charge and trigger
	184
	185	TH2F * fhNeutralLeadingPt ; //! Pt(Pt trigger) distribution of neutral hadrons
	186	TH2F * fhNeutralLeadingPhi ; //! Phi(Pt trigger) distribution of neutral hadrons
	187	TH2F * fhNeutralLeadingEta ; //! Eta(Pt trigger) distribution of neutral hadrons
	188	TH2F * fhNeutralLeadingDeltaPt ; //! Difference of neutral hadron and trigger pT as function of trigger pT
	189	TH2F * fhNeutralLeadingDeltaPhi ; //! Difference of neutral hadron and trigger phi as function of trigger pT
	190	TH2F * fhNeutralLeadingDeltaEta ; //! Difference of charged particle and trigger eta as function of trigger pT
	191	TH2F * fhNeutralLeadingRatioPt ; //! Ratio of Pt leading neutral and trigger
9415d854	192
	193	TH2F * fhChargedLeadingXi ; //! Ln (pt leading charge / pt trigger)
	194	TH2F * fhNeutralLeadingXi ; //! Ln (pt leading neutral / pt trigger)
dde5a268	195
	196	TH2F * fhChargedLeadingDeltaPhiRatioPt30 ; //! Difference of charged hadron and trigger phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
	197	TH2F * fhNeutralLeadingDeltaPhiRatioPt30 ; //! Difference of neutral hadron and trigger phi as function of pT leading / trigger pT, pT Trigger > 30 GeV
	198	TH2F * fhChargedLeadingDeltaPhiRatioPt50 ; //! Difference of charged hadron and trigger phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
	199	TH2F * fhNeutralLeadingDeltaPhiRatioPt50 ; //! Difference of neutral hadron and trigger phi as function of pT leading / trigger pT, pT Trigger > 50 GeV
9415d854	200
1c5acb87	201	// Jet distributions
	202	// Fixed cone and pt threshold
	203	TH2F * fhJetPt ; //! leading pt jet vs pt trigger
	204	TH2F * fhJetRatioPt ; //! Ratio of pt jet and pt trigger
	205	TH2F * fhJetDeltaPhi ; //! Delta phi jet-trigger
	206	TH2F * fhJetDeltaEta ; //! Delta eta jet-trigger
	207	TH2F * fhJetLeadingRatioPt ; //! Ratio of pt leading and pt jet
	208	TH2F * fhJetLeadingDeltaPhi ; //! Delta phi jet-leading
	209	TH2F * fhJetLeadingDeltaEta ; //! Delta eta jet-leading
	210	TH2F * fhJetFFz; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
	211	TH2F * fhJetFFxi; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
	212	TH2F * fhJetFFpt; //! Jet particle pt distribution in cone
	213	TH2F * fhJetNTracksInCone ; //! jet multiplicity in cone
	214
	215	TH2F * fhBkgPt ; //! leading pt bakground vs pt trigger
	216	TH2F * fhBkgRatioPt ; //! Ratio of pt background and pt trigger
	217	TH2F * fhBkgDeltaPhi ; //! Delta phi background-trigger
	218	TH2F * fhBkgDeltaEta ; //! Delta eta background-trigger
	219	TH2F * fhBkgLeadingRatioPt ; //! Ratio of pt leading and pt background
	220	TH2F * fhBkgLeadingDeltaPhi ; //! Delta phi background-leading
	221	TH2F * fhBkgLeadingDeltaEta ; //! Delta eta background-leading
	222	TH2F * fhBkgFFz; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
	223	TH2F * fhBkgFFxi; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
	224	TH2F * fhBkgFFpt; //! Background particle pt distribution in cone
	225	TH2F * fhBkgNTracksInCone ; //! Background multiplicity in cone
	226
	227	// Variable cone and pt threshold
	228
	229	TH2F * fhJetPts[5][5]; //! leading pt jet vs pt trigger
	230	TH2F * fhJetRatioPts[5][5]; //! Ratio of pt jet and pt trigger
	231	TH2F * fhJetDeltaPhis[5][5]; //! Delta phi jet-trigger
	232	TH2F * fhJetDeltaEtas[5][5]; //! Delta eta jet-trigger
	233	TH2F * fhJetLeadingRatioPts[5][5]; //! Ratio of pt leading and pt jet
	234	TH2F * fhJetLeadingDeltaPhis[5][5]; //! Delta phi jet-leading
	235	TH2F * fhJetLeadingDeltaEtas[5][5]; //! Delta eta jet-leading
	236	TH2F * fhJetFFzs[5][5]; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
	237	TH2F * fhJetFFxis[5][5]; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
	238	TH2F * fhJetFFpts[5][5]; //! Jet particle pt distribution in cone
	239	TH2F * fhJetNTracksInCones[5][5]; //! jet multiplicity in cone
	240
	241	TH2F * fhBkgPts[5][5]; //! leading pt bakground vs pt trigger
	242	TH2F * fhBkgRatioPts[5][5]; //! Ratio of pt background and pt trigger
	243	TH2F * fhBkgDeltaPhis[5][5]; //! Delta phi background-trigger
	244	TH2F * fhBkgDeltaEtas[5][5]; //! Delta eta background-trigger
	245	TH2F * fhBkgLeadingRatioPts[5][5]; //! Ratio of pt leading and pt background
	246	TH2F * fhBkgLeadingDeltaPhis[5][5]; //! Delta phi background-leading
	247	TH2F * fhBkgLeadingDeltaEtas[5][5]; //! Delta eta background-leading
	248	TH2F * fhBkgFFzs[5][5]; //! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
	249	TH2F * fhBkgFFxis[5][5]; //! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet)
	250	TH2F * fhBkgFFpts[5][5]; //! Background particle pt distribution in cone
	251	TH2F * fhBkgNTracksInCones[5][5]; //! Background multiplicity in cone
	252
	253
	254	ClassDef(AliAnaParticleJetLeadingConeCorrelation,1)
	255	} ;
	256
	257
	258	#endif //ALIANAPARTICLEJETLEADINGCONECORRELATION_H
	259
	260
	261