[u/mrichter/AliRoot.git] / PWG4 / 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 AliAODParticleCorrelation,
// 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;
class AliLog;

#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 ; }
  
 private:
  
  Double_t CalculateJetRatioLimit(const Double_t ptTrig, const Double_t *param, const Double_t *x);
  
  void FillJetHistos(AliAODParticleCorrelation * particle, const TLorentzVector  leading, const TLorentzVector jet, const TString type, const TString lastname);
  
  TList * GetOutputContainer() {return fOutCont; }
  
  Bool_t IsJetSelected(const Double_t ptTrig, const Double_t ptjet);
  Bool_t IsParticleInJetCone(const Double_t eta, Double_t phi, const Double_t etal, Double_t phil);
  
  void GetLeadingCharge(AliAODParticleCorrelation *particle, TLorentzVector & pLeading) ;
  void GetLeadingPi0   (AliAODParticleCorrelation *particle, TLorentzVector & pLeading)  ;
  Bool_t GetLeadingParticle(AliAODParticleCorrelation *particle, TLorentzVector &  pLeading) ;
  
  void MakeAnalysisFillAOD();
  void MakeAnalysisFillHistograms();   
  void MakeAODJet(AliAODParticleCorrelation * particle, const TLorentzVector pLeading); 
  void MakeJetFromAOD(AliAODParticleCorrelation * particle, const TLorentzVector pLeading, 
		      TLorentzVector & jet, TLorentzVector & bkg); 
  
  Bool_t  SelectCluster(AliAODCaloCluster * calo, Double_t *vertex, TLorentzVector & mom, Int_t & pdg) ;
  
 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.
  
  //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

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