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

#ifndef AliJetContainer_H
#define AliJetContainer_H

// $Id$

class TClonesArray;
class TString;

class AliEMCALGeometry;
class AliEmcalJet;
class AliVEvent;
class AliParticleContainer;
class AliClusterContainer;
class AliLocalRhoParameter;
class AliPythiaInfo;

#include <TMath.h>
#include "AliRhoParameter.h"
#include "AliEmcalContainer.h"
#include "AliLog.h"
#include "AliVEvent.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 SetEMCALGeometry();
  void SetEMCALGeometry(AliEMCALGeometry *p) {fGeom = p;}
  void LoadRho(AliVEvent *event);
  void LoadLocalRho(AliVEvent *event);
  void LoadRhoMass(AliVEvent *event);
  void LoadPythiaInfo(AliVEvent *event);

  void                        SetJetAcceptanceType(JetAcceptanceType type)         { fJetAcceptanceType          = type ; }
  void                        PrintCuts();
  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                        SetJetPtCut(Float_t cut)                             { fJetPtCut       = cut              ; }
  void                        SetJetRadius(Float_t r)                              { fJetRadius      = r                ; } 
  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                        SetZLeadingCut(Float_t zemc, Float_t zch)            { fZLeadingEmcCut = zemc; fZLeadingChCut = zch ; }
  void                        SetNEFCut(Float_t min = 0., Float_t max = 1.)        { fNEFMinCut = min; fNEFMaxCut = max;  }
  void                        SetFlavourCut(Int_t myflavour)                       { fFlavourSelection = myflavour;}
  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                        SetTagStatus(Int_t i)                                { fTagStatus      = i                ; }

  virtual void                SetRhoName(const char *n)                            { fRhoName        = n                ; }
  virtual void                SetLocalRhoName(const char *n)                       { fLocalRhoName   = n                ; }
  virtual void                SetRhoMassName(const char *n)                        { fRhoMassName    = n                ; }
  virtual void                SetPythiaInfoName(const char *n)                      { fPythiaInfoName    = n; }
    
  void                        ConnectParticleContainer(AliParticleContainer *c)    { fParticleContainer = c             ; }
  void                        ConnectClusterContainer(AliClusterContainer *c)      { fClusterContainer  = c             ; }

  AliEmcalJet                *GetLeadingJet(const char* opt="")          ;
  AliEmcalJet                *GetJet(Int_t i)                       const;
  AliEmcalJet                *GetAcceptJet(Int_t i)                      ;
  AliEmcalJet                *GetJetWithLabel(Int_t lab)            const;
  AliEmcalJet                *GetAcceptJetWithLabel(Int_t lab)           ;
  AliEmcalJet                *GetNextAcceptJet(Int_t i=-1)               ;
  AliEmcalJet                *GetNextJet(Int_t i=-1)                     ;
  void                        GetMomentum(TLorentzVector &mom, Int_t i) const;
  Bool_t                      AcceptJet(const AliEmcalJet* jet)          ;
  Bool_t                      AcceptBiasJet(const AliEmcalJet* jet)      ;
  Int_t                       GetFlavourCut()                       const    {return fFlavourSelection;}
  Int_t                       GetNJets()                            const    {return GetNEntries();}
  Double_t                    GetLeadingHadronPt(const AliEmcalJet* jet)  const;
  void                        GetLeadingHadronMomentum(TLorentzVector &mom, const AliEmcalJet* jet)  const;
  Double_t                    GetZ(const AliEmcalJet *jet, TLorentzVector mom) const;
  Double_t                    GetZLeadingEmc(const AliEmcalJet *jet)      const;
  Double_t                    GetZLeadingCharged(const AliEmcalJet *jet)  const;
  AliRhoParameter            *GetRhoParameter()                              {return fRho;}
  Double_t                    GetRhoVal()                           const    {if (fRho) return fRho->GetVal(); else return 0;}
  const TString&              GetRhoName()                          const    {return fRhoName;}
  AliLocalRhoParameter       *GetLocalRhoParameter()                const    {return fLocalRho;}
  const TString&              GetLocalRhoName()                     const    {return fLocalRhoName;}
  AliRhoParameter            *GetRhoMassParameter()                          {return fRhoMass;}
  Double_t                    GetRhoMassVal()                       const    {if (fRhoMass) return fRhoMass->GetVal(); else return 0;}
  const TString&              GetRhoMassName()                      const    {return fRhoMassName;}
  const TString&              GetPythiaInfoName()                   const    {return fPythiaInfoName;}
  AliPythiaInfo         *GetPythiaInfo()                  const    {return fPythiaInfo;}
  Double_t                    GetJetPtCorr(Int_t i)                 const;
  Double_t                    GetJetPtCorrLocal(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;}
  Float_t                     GetJetPtCut()                         const    {return fJetPtCut;}
  void                        SetClassName(const char *clname);
  void                        SetArray(AliVEvent *event);
  AliParticleContainer       *GetParticleContainer() const                   {return fParticleContainer;}
  AliClusterContainer        *GetClusterContainer() const                    {return fClusterContainer;}
  Double_t                    GetFractionSharedPt(const AliEmcalJet *jet) const;
 

 protected:
  JetAcceptanceType           fJetAcceptanceType;    //  acceptance type
  Float_t                     fJetRadius;            //  jet radius
  TString                     fRhoName;              //  Name of rho object
  TString                     fLocalRhoName;         //  Name of local rho object
  TString                     fRhoMassName;          //  Name of rho mass object
  TString                     fPythiaInfoName;       //  Name of pythia info object
  Int_t                       fFlavourSelection;     //  selection on jet flavour
  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
  Float_t                     fZLeadingEmcCut;       //  maximum z,leading neutral
  Float_t                     fZLeadingChCut;        //  maximum z,leading charged
  Float_t                     fNEFMinCut;            //  minimum NEF in a jet
  Float_t                     fNEFMaxCut;            //  maximum NEF in a 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
  Int_t                       fTagStatus;            //  jet tag status
  AliParticleContainer       *fParticleContainer;    //  particle container (jet constituents)
  AliClusterContainer        *fClusterContainer;     //  cluster container (jet constituents)
  AliRhoParameter            *fRho;                  //! event rho for these jets
  AliLocalRhoParameter       *fLocalRho;             //! event local rho for these jets
  AliRhoParameter            *fRhoMass;              //! event rho mass for these jets
  AliPythiaInfo         *fPythiaInfo;          //! event parton info
  AliEMCALGeometry           *fGeom;                 //! emcal geometry
  Int_t                       fRunNumber;            //! run number

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

  ClassDef(AliJetContainer,10);

};

#endif
Commit	Line	Data
421b12a3	1	#ifndef AliJetContainer_H
	2	#define AliJetContainer_H
	3
9239b066	4	// $Id$
421b12a3	5
421b12a3	6	class TClonesArray;
421b12a3	7	class TString;
6421eeb0	8
421b12a3	9	class AliEMCALGeometry;
	10	class AliEmcalJet;
	11	class AliVEvent;
6421eeb0	12	class AliParticleContainer;
6421eeb0	13	class AliClusterContainer;
9e5eee5d	14	class AliLocalRhoParameter;
b929303d	15	class AliPythiaInfo;
421b12a3	16
b4d8a739	17	#include <TMath.h>
421b12a3	18	#include "AliRhoParameter.h"
6421eeb0	19	#include "AliEmcalContainer.h"
b4d8a739	20	#include "AliLog.h"
b4d8a739	21	#include "AliVEvent.h"
421b12a3	22
	23	class AliJetContainer : public AliEmcalContainer {
	24	public:
6421eeb0	25
421b12a3	26	enum JetAcceptanceType {
	27	kTPC = 0, // TPC acceptance
	28	kEMCAL = 1, // EMCal acceptance
4c9493a7	29	kUser = 2 // User defined acceptance
421b12a3	30	};
	31
	32
	33	AliJetContainer();
	34	AliJetContainer(const char *name);
6421eeb0	35	virtual ~AliJetContainer() {;}
421b12a3	36
421b12a3	37	void SetEMCALGeometry();
	38	void SetEMCALGeometry(AliEMCALGeometry *p) {fGeom = p;}
	39	void LoadRho(AliVEvent *event);
9e5eee5d	40	void LoadLocalRho(AliVEvent *event);
4d3b366f	41	void LoadRhoMass(AliVEvent *event);
b929303d	42	void LoadPythiaInfo(AliVEvent *event);
421b12a3	43
421b12a3	44	void SetJetAcceptanceType(JetAcceptanceType type) { fJetAcceptanceType = type ; }
6c3dc2d6	45	void PrintCuts();
421b12a3	46	void ResetCuts();
421b12a3	47	void SetJetEtaPhiEMCAL() ;
421b12a3	48	void SetJetEtaPhiTPC() ;
56f370b0	49	void SetRunNumber(Int_t r) { fRunNumber = r; }
421b12a3	50	void SetJetEtaLimits(Float_t min, Float_t max) { fJetMinEta = min, fJetMaxEta = max ; }
421b12a3	51	void SetJetPhiLimits(Float_t min, Float_t max) { fJetMinPhi = min, fJetMaxPhi = max ; }
7a615dc4	52	void SetJetPtCut(Float_t cut) { fJetPtCut = cut ; }
7a615dc4	53	void SetJetRadius(Float_t r) { fJetRadius = r ; }
421b12a3	54	void SetJetAreaCut(Float_t cut) { fJetAreaCut = cut ; }
9239b066	55	void SetPercAreaCut(Float_t p) { if(fJetRadius==0.) AliWarning("JetRadius not set. Area cut will be 0");
9239b066	56	fJetAreaCut = pTMath::Pi()fJetRadius*fJetRadius; }
7a615dc4	57	void SetAreaEmcCut(Double_t a = 0.99) { fAreaEmcCut = a ; }
413ab3a3	58	void SetZLeadingCut(Float_t zemc, Float_t zch) { fZLeadingEmcCut = zemc; fZLeadingChCut = zch ; }
9e5eee5d	59	void SetNEFCut(Float_t min = 0., Float_t max = 1.) { fNEFMinCut = min; fNEFMaxCut = max; }
3c9775d9	60	void SetFlavourCut(Int_t myflavour) { fFlavourSelection = myflavour;}
421b12a3	61	void SetMaxClusterPt(Float_t b) { fMaxClusterPt = b ; }
	62	void SetMaxTrackPt(Float_t b) { fMaxTrackPt = b ; }
	63	void SetPtBiasJetClus(Float_t b) { fPtBiasJetClus = b ; }
	64	void SetNLeadingJets(Int_t t) { fNLeadingJets = t ; }
	65	void SetPtBiasJetTrack(Float_t b) { fPtBiasJetTrack = b ; }
421b12a3	66	void SetLeadingHadronType(Int_t t) { fLeadingHadronType = t ; }
421b12a3	67	void SetJetBitMap(UInt_t m) { fJetBitMap = m ; }
6421eeb0	68	void SetJetTrigger(UInt_t t=AliVEvent::kEMCEJE) { fJetTrigger = t ; }
7a615dc4	69	void SetTagStatus(Int_t i) { fTagStatus = i ; }
	70
	71	virtual void SetRhoName(const char *n) { fRhoName = n ; }
	72	virtual void SetLocalRhoName(const char *n) { fLocalRhoName = n ; }
4d3b366f	73	virtual void SetRhoMassName(const char *n) { fRhoMassName = n ; }
b929303d	74	virtual void SetPythiaInfoName(const char *n) { fPythiaInfoName = n; }
cfa7b4df	75
7cd832c7	76	void ConnectParticleContainer(AliParticleContainer *c) { fParticleContainer = c ; }
7cd832c7	77	void ConnectClusterContainer(AliClusterContainer *c) { fClusterContainer = c ; }
ba7663ad	78
b6f970ad	79	AliEmcalJet GetLeadingJet(const char opt="") ;
6421eeb0	80	AliEmcalJet *GetJet(Int_t i) const;
6504c17f	81	AliEmcalJet *GetAcceptJet(Int_t i) ;
7cd832c7	82	AliEmcalJet *GetJetWithLabel(Int_t lab) const;
6504c17f	83	AliEmcalJet *GetAcceptJetWithLabel(Int_t lab) ;
b6f970ad	84	AliEmcalJet *GetNextAcceptJet(Int_t i=-1) ;
7cd832c7	85	AliEmcalJet *GetNextJet(Int_t i=-1) ;
6421eeb0	86	void GetMomentum(TLorentzVector &mom, Int_t i) const;
983c25fc	87	Bool_t AcceptJet(const AliEmcalJet* jet) ;
983c25fc	88	Bool_t AcceptBiasJet(const AliEmcalJet* jet) ;
3c9775d9	89	Int_t GetFlavourCut() const {return fFlavourSelection;}
421b12a3	90	Int_t GetNJets() const {return GetNEntries();}
983c25fc	91	Double_t GetLeadingHadronPt(const AliEmcalJet* jet) const;
	92	void GetLeadingHadronMomentum(TLorentzVector &mom, const AliEmcalJet* jet) const;
	93	Double_t GetZ(const AliEmcalJet *jet, TLorentzVector mom) const;
	94	Double_t GetZLeadingEmc(const AliEmcalJet *jet) const;
	95	Double_t GetZLeadingCharged(const AliEmcalJet *jet) const;
421b12a3	96	AliRhoParameter *GetRhoParameter() {return fRho;}
3c9775d9	97	Double_t GetRhoVal() const {if (fRho) return fRho->GetVal(); else return 0;}
421b12a3	98	const TString& GetRhoName() const {return fRhoName;}
9e5eee5d	99	AliLocalRhoParameter *GetLocalRhoParameter() const {return fLocalRho;}
9e5eee5d	100	const TString& GetLocalRhoName() const {return fLocalRhoName;}
4d3b366f	101	AliRhoParameter *GetRhoMassParameter() {return fRhoMass;}
	102	Double_t GetRhoMassVal() const {if (fRhoMass) return fRhoMass->GetVal(); else return 0;}
	103	const TString& GetRhoMassName() const {return fRhoMassName;}
b929303d	104	const TString& GetPythiaInfoName() const {return fPythiaInfoName;}
b929303d	105	AliPythiaInfo *GetPythiaInfo() const {return fPythiaInfo;}
421b12a3	106	Double_t GetJetPtCorr(Int_t i) const;
9e5eee5d	107	Double_t GetJetPtCorrLocal(Int_t i) const;
56f370b0	108	Float_t GetJetRadius() const {return fJetRadius;}
4c9493a7	109	Float_t GetJetEtaMin() const {return fJetMinEta;}
	110	Float_t GetJetEtaMax() const {return fJetMaxEta;}
	111	Float_t GetJetPhiMin() const {return fJetMinPhi;}
	112	Float_t GetJetPhiMax() const {return fJetMaxPhi;}
b48964d0	113	Float_t GetJetPtCut() const {return fJetPtCut;}
b6f970ad	114	void SetClassName(const char *clname);
b6f970ad	115	void SetArray(AliVEvent *event);
3617787b	116	AliParticleContainer *GetParticleContainer() const {return fParticleContainer;}
3617787b	117	AliClusterContainer *GetClusterContainer() const {return fClusterContainer;}
1705bab1	118	Double_t GetFractionSharedPt(const AliEmcalJet *jet) const;
cfa7b4df	119
421b12a3	120
	121	protected:
	122	JetAcceptanceType fJetAcceptanceType; // acceptance type
	123	Float_t fJetRadius; // jet radius
	124	TString fRhoName; // Name of rho object
9e5eee5d	125	TString fLocalRhoName; // Name of local rho object
4d3b366f	126	TString fRhoMassName; // Name of rho mass object
b929303d	127	TString fPythiaInfoName; // Name of pythia info object
3c9775d9	128	Int_t fFlavourSelection; // selection on jet flavour
421b12a3	129	Float_t fPtBiasJetTrack; // select jets with a minimum pt track
	130	Float_t fPtBiasJetClus; // select jets with a minimum pt cluster
	131	Float_t fJetPtCut; // cut on jet pt
	132	Float_t fJetAreaCut; // cut on jet area
	133	Float_t fAreaEmcCut; // minimum cut on jet emcal area
	134	Float_t fJetMinEta; // minimum eta jet acceptance
	135	Float_t fJetMaxEta; // maximum eta jet acceptance
	136	Float_t fJetMinPhi; // minimum phi jet acceptance
	137	Float_t fJetMaxPhi; // maximum phi jet acceptance
	138	Float_t fMaxClusterPt; // maximum cluster constituent pt to accept the jet
	139	Float_t fMaxTrackPt; // maximum track constituent pt to accept the jet
413ab3a3	140	Float_t fZLeadingEmcCut; // maximum z,leading neutral
413ab3a3	141	Float_t fZLeadingChCut; // maximum z,leading charged
9e5eee5d	142	Float_t fNEFMinCut; // minimum NEF in a jet
9e5eee5d	143	Float_t fNEFMaxCut; // maximum NEF in a jet
421b12a3	144	Int_t fLeadingHadronType; // 0 = charged, 1 = neutral, 2 = both
	145	Int_t fNLeadingJets; // how many jets are to be considered the leading jet(s)
	146	UInt_t fJetBitMap; // bit map of accepted jets
6421eeb0	147	UInt_t fJetTrigger; // jet trigger
7a615dc4	148	Int_t fTagStatus; // jet tag status
7cd832c7	149	AliParticleContainer *fParticleContainer; // particle container (jet constituents)
7cd832c7	150	AliClusterContainer *fClusterContainer; // cluster container (jet constituents)
6421eeb0	151	AliRhoParameter *fRho; //! event rho for these jets
9e5eee5d	152	AliLocalRhoParameter *fLocalRho; //! event local rho for these jets
4d3b366f	153	AliRhoParameter *fRhoMass; //! event rho mass for these jets
b929303d	154	AliPythiaInfo *fPythiaInfo; //! event parton info
6421eeb0	155	AliEMCALGeometry *fGeom; //! emcal geometry
6421eeb0	156	Int_t fRunNumber; //! run number
421b12a3	157
	158	private:
	159	AliJetContainer(const AliJetContainer& obj); // copy constructor
	160	AliJetContainer& operator=(const AliJetContainer& other); // assignment
	161
51e5aebd	162	ClassDef(AliJetContainer,10);
421b12a3	163
	164	};
	165
	166	#endif