[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / AliJetContainer.h

#ifndef AliJetContainer_H
#define AliJetContainer_H

//
// container with name, TClonesArray and cuts for jets
//

class TClonesArray;
class TString;

class AliEMCALGeometry;
class AliEmcalJet;
class AliVEvent;
class AliParticleContainer;
class AliClusterContainer;

#include "AliRhoParameter.h"

#include "AliEmcalContainer.h"

class AliJetContainer : public AliEmcalContainer {
 public:
 
  enum JetAcceptanceType {
    kTPC       = 0,     // TPC acceptance
    kEMCAL     = 1,     // EMCal acceptance
    kUser      = 2      // User defined acceptance
  };


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

  void SetJetArray(AliVEvent *event);
  void SetEMCALGeometry();
  void SetEMCALGeometry(AliEMCALGeometry *p) {fGeom = p;}
  void LoadRho(AliVEvent *event);

  void                        SetJetAcceptanceType(JetAcceptanceType type)         { fJetAcceptanceType          = type ; }

  void                        ResetCuts();

  void                        SetJetEtaPhiEMCAL() ;
  void                        SetJetEtaPhiTPC()   ;
  void                        SetRunNumber(Int_t r)                                { fRunNumber = r;                      }

  void                        SetJetEtaLimits(Float_t min, Float_t max)            { fJetMinEta = min, fJetMaxEta = max ; }
  void                        SetJetPhiLimits(Float_t min, Float_t max)            { fJetMinPhi = min, fJetMaxPhi = max ; }
  void                        SetJetAreaCut(Float_t cut)                           { fJetAreaCut     = cut              ; }
  void                        SetPercAreaCut(Float_t p)                            { if(fJetRadius==0.) AliWarning("JetRadius not set. Area cut will be 0"); fJetAreaCut = p*TMath::Pi()*fJetRadius*fJetRadius; }

  void                        SetAreaEmcCut(Double_t a = 0.99)                     { fAreaEmcCut     = a                ; }
  void                        SetJetPtCut(Float_t cut)                             { fJetPtCut       = cut              ; }
  void                        SetJetRadius(Float_t r)                              { fJetRadius      = r                ; } 
  virtual void                SetRhoName(const char *n)                            { fRhoName        = n                ; }
  void                        SetMaxClusterPt(Float_t b)                           { fMaxClusterPt   = b                ; }
  void                        SetMaxTrackPt(Float_t b)                             { fMaxTrackPt     = b                ; }
  void                        SetPtBiasJetClus(Float_t b)                          { fPtBiasJetClus  = b                ; }
  void                        SetNLeadingJets(Int_t t)                             { fNLeadingJets   = t                ; }
  void                        SetPtBiasJetTrack(Float_t b)                         { fPtBiasJetTrack = b                ; }

  void                        SetLeadingHadronType(Int_t t)                        { fLeadingHadronType = t             ; }
  void                        SetJetBitMap(UInt_t m)                               { fJetBitMap      = m                ; }
  void                        SetJetTrigger(UInt_t t=AliVEvent::kEMCEJE)           { fJetTrigger     = t                ; }

  void                        SetParticleContainer(AliParticleContainer *c)        { fParticleContainer = c             ; }
  void                        SetClusterContainer(AliClusterContainer *c)          { fClusterContainer  = c             ; }

  AliEmcalJet                *GetLeadingJet(const char* opt="")     const;
  AliEmcalJet                *GetJet(Int_t i)                       const;
  AliEmcalJet                *GetAcceptJet(Int_t i)                 const;
  AliEmcalJet                *GetNextAcceptJet(Int_t i=-1)          const;
  void                        GetMomentum(TLorentzVector &mom, Int_t i) const;
  Bool_t                      AcceptJet(AliEmcalJet* jet)           const;
  Bool_t                      AcceptBiasJet(AliEmcalJet* jet)       const; 
  Int_t                       GetNJets()                            const    {return GetNEntries();}
  Double_t                    GetLeadingHadronPt(AliEmcalJet* jet)  const;
  void                        GetLeadingHadronMomentum(TLorentzVector &mom, AliEmcalJet* jet)  const;
  AliRhoParameter            *GetRhoParameter()                              {return fRho;}
  Double_t                    GetRhoVal()                           const    {return fRho->GetVal();}
  const TString&              GetRhoName()                          const    {return fRhoName;}
  Double_t                    GetJetPtCorr(Int_t i)                 const;
  Float_t                     GetJetRadius()                        const    {return fJetRadius;}
  Float_t                     GetJetEtaMin()                        const    {return fJetMinEta;}
  Float_t                     GetJetEtaMax()                        const    {return fJetMaxEta;}
  Float_t                     GetJetPhiMin()                        const    {return fJetMinPhi;}
  Float_t                     GetJetPhiMax()                        const    {return fJetMaxPhi;}

 protected:
  JetAcceptanceType           fJetAcceptanceType;    //  acceptance type
  Float_t                     fJetRadius;            //  jet radius
  TString                     fRhoName;              //  Name of rho object
  Float_t                     fPtBiasJetTrack;       //  select jets with a minimum pt track
  Float_t                     fPtBiasJetClus;        //  select jets with a minimum pt cluster
  Float_t                     fJetPtCut;             //  cut on jet pt
  Float_t                     fJetAreaCut;           //  cut on jet area
  Float_t                     fAreaEmcCut;           //  minimum cut on jet emcal area
  Float_t                     fJetMinEta;            //  minimum eta jet acceptance
  Float_t                     fJetMaxEta;            //  maximum eta jet acceptance
  Float_t                     fJetMinPhi;            //  minimum phi jet acceptance
  Float_t                     fJetMaxPhi;            //  maximum phi jet acceptance  
  Float_t                     fMaxClusterPt;         //  maximum cluster constituent pt to accept the jet
  Float_t                     fMaxTrackPt;           //  maximum track constituent pt to accept the jet
  Int_t                       fLeadingHadronType;    //  0 = charged, 1 = neutral, 2 = both
  Int_t                       fNLeadingJets;         //  how many jets are to be considered the leading jet(s)
  UInt_t                      fJetBitMap;            //  bit map of accepted jets
  UInt_t                      fJetTrigger;           //  jet trigger

  AliParticleContainer       *fParticleContainer;    //! particle container (jet constituents)
  AliClusterContainer        *fClusterContainer;     //! cluster container (jet constituents)
  AliRhoParameter            *fRho;                  //! event rho for these jets
  AliEMCALGeometry           *fGeom;                 //! emcal geometry
  Int_t                       fRunNumber;            //! run number

 private:
  AliJetContainer(const AliJetContainer& obj); // copy constructor
  AliJetContainer& operator=(const AliJetContainer& other); // assignment

  ClassDef(AliJetContainer,2);

};

#endif
Commit	Line	Data
421b12a3	1	#ifndef AliJetContainer_H
	2	#define AliJetContainer_H
	3
	4	//
	5	// container with name, TClonesArray and cuts for jets
	6	//
	7
421b12a3	8	class TClonesArray;
421b12a3	9	class TString;
6421eeb0	10
421b12a3	11	class AliEMCALGeometry;
	12	class AliEmcalJet;
	13	class AliVEvent;
6421eeb0	14	class AliParticleContainer;
6421eeb0	15	class AliClusterContainer;
421b12a3	16
421b12a3	17	#include "AliRhoParameter.h"
421b12a3	18
6421eeb0	19	#include "AliEmcalContainer.h"
421b12a3	20
	21	class AliJetContainer : public AliEmcalContainer {
	22	public:
6421eeb0	23
421b12a3	24	enum JetAcceptanceType {
	25	kTPC = 0, // TPC acceptance
	26	kEMCAL = 1, // EMCal acceptance
4c9493a7	27	kUser = 2 // User defined acceptance
421b12a3	28	};
	29
	30
	31	AliJetContainer();
	32	AliJetContainer(const char *name);
6421eeb0	33	virtual ~AliJetContainer() {;}
421b12a3	34
	35	void SetJetArray(AliVEvent *event);
	36	void SetEMCALGeometry();
	37	void SetEMCALGeometry(AliEMCALGeometry *p) {fGeom = p;}
	38	void LoadRho(AliVEvent *event);
	39
	40	void SetJetAcceptanceType(JetAcceptanceType type) { fJetAcceptanceType = type ; }
	41
	42	void ResetCuts();
	43
	44	void SetJetEtaPhiEMCAL() ;
	45	void SetJetEtaPhiTPC() ;
56f370b0	46	void SetRunNumber(Int_t r) { fRunNumber = r; }
421b12a3	47
	48	void SetJetEtaLimits(Float_t min, Float_t max) { fJetMinEta = min, fJetMaxEta = max ; }
	49	void SetJetPhiLimits(Float_t min, Float_t max) { fJetMinPhi = min, fJetMaxPhi = max ; }
	50	void SetJetAreaCut(Float_t cut) { fJetAreaCut = cut ; }
	51	void SetPercAreaCut(Float_t p) { if(fJetRadius==0.) AliWarning("JetRadius not set. Area cut will be 0"); fJetAreaCut = pTMath::Pi()fJetRadius*fJetRadius; }
	52
	53	void SetAreaEmcCut(Double_t a = 0.99) { fAreaEmcCut = a ; }
	54	void SetJetPtCut(Float_t cut) { fJetPtCut = cut ; }
	55	void SetJetRadius(Float_t r) { fJetRadius = r ; }
	56	virtual void SetRhoName(const char *n) { fRhoName = n ; }
	57	void SetMaxClusterPt(Float_t b) { fMaxClusterPt = b ; }
	58	void SetMaxTrackPt(Float_t b) { fMaxTrackPt = b ; }
	59	void SetPtBiasJetClus(Float_t b) { fPtBiasJetClus = b ; }
	60	void SetNLeadingJets(Int_t t) { fNLeadingJets = t ; }
	61	void SetPtBiasJetTrack(Float_t b) { fPtBiasJetTrack = b ; }
	62
	63	void SetLeadingHadronType(Int_t t) { fLeadingHadronType = t ; }
	64	void SetJetBitMap(UInt_t m) { fJetBitMap = m ; }
6421eeb0	65	void SetJetTrigger(UInt_t t=AliVEvent::kEMCEJE) { fJetTrigger = t ; }
421b12a3	66
6421eeb0	67	void SetParticleContainer(AliParticleContainer *c) { fParticleContainer = c ; }
	68	void SetClusterContainer(AliClusterContainer *c) { fClusterContainer = c ; }
	69
	70	AliEmcalJet GetLeadingJet(const char opt="") const;
	71	AliEmcalJet *GetJet(Int_t i) const;
421b12a3	72	AliEmcalJet *GetAcceptJet(Int_t i) const;
6421eeb0	73	AliEmcalJet *GetNextAcceptJet(Int_t i=-1) const;
	74	void GetMomentum(TLorentzVector &mom, Int_t i) const;
	75	Bool_t AcceptJet(AliEmcalJet* jet) const;
421b12a3	76	Bool_t AcceptBiasJet(AliEmcalJet* jet) const;
	77	Int_t GetNJets() const {return GetNEntries();}
	78	Double_t GetLeadingHadronPt(AliEmcalJet* jet) const;
6421eeb0	79	void GetLeadingHadronMomentum(TLorentzVector &mom, AliEmcalJet* jet) const;
421b12a3	80	AliRhoParameter *GetRhoParameter() {return fRho;}
	81	Double_t GetRhoVal() const {return fRho->GetVal();}
	82	const TString& GetRhoName() const {return fRhoName;}
	83	Double_t GetJetPtCorr(Int_t i) const;
56f370b0	84	Float_t GetJetRadius() const {return fJetRadius;}
4c9493a7	85	Float_t GetJetEtaMin() const {return fJetMinEta;}
	86	Float_t GetJetEtaMax() const {return fJetMaxEta;}
	87	Float_t GetJetPhiMin() const {return fJetMinPhi;}
	88	Float_t GetJetPhiMax() const {return fJetMaxPhi;}
421b12a3	89
	90	protected:
	91	JetAcceptanceType fJetAcceptanceType; // acceptance type
	92	Float_t fJetRadius; // jet radius
	93	TString fRhoName; // Name of rho object
	94	Float_t fPtBiasJetTrack; // select jets with a minimum pt track
	95	Float_t fPtBiasJetClus; // select jets with a minimum pt cluster
	96	Float_t fJetPtCut; // cut on jet pt
	97	Float_t fJetAreaCut; // cut on jet area
	98	Float_t fAreaEmcCut; // minimum cut on jet emcal area
	99	Float_t fJetMinEta; // minimum eta jet acceptance
	100	Float_t fJetMaxEta; // maximum eta jet acceptance
	101	Float_t fJetMinPhi; // minimum phi jet acceptance
	102	Float_t fJetMaxPhi; // maximum phi jet acceptance
	103	Float_t fMaxClusterPt; // maximum cluster constituent pt to accept the jet
	104	Float_t fMaxTrackPt; // maximum track constituent pt to accept the jet
	105	Int_t fLeadingHadronType; // 0 = charged, 1 = neutral, 2 = both
	106	Int_t fNLeadingJets; // how many jets are to be considered the leading jet(s)
	107	UInt_t fJetBitMap; // bit map of accepted jets
6421eeb0	108	UInt_t fJetTrigger; // jet trigger
421b12a3	109
6421eeb0	110	AliParticleContainer *fParticleContainer; //! particle container (jet constituents)
	111	AliClusterContainer *fClusterContainer; //! cluster container (jet constituents)
	112	AliRhoParameter *fRho; //! event rho for these jets
	113	AliEMCALGeometry *fGeom; //! emcal geometry
	114	Int_t fRunNumber; //! run number
421b12a3	115
	116	private:
	117	AliJetContainer(const AliJetContainer& obj); // copy constructor
	118	AliJetContainer& operator=(const AliJetContainer& other); // assignment
	119
6421eeb0	120	ClassDef(AliJetContainer,2);
421b12a3	121
	122	};
	123
	124	#endif
	125
	126