[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / UserTasks / AliAnalysisTaskJetMatching.h

#ifndef AliAnalysisTaskJetMatching_H
#define AliAnalysisTaskJetMatching_H

#include <AliAnalysisTaskEmcalJet.h>
#include <AliEmcalJet.h>
#include <AliVTrack.h>
#include <TClonesArray.h>
#include <TMath.h>
#include <TRandom3.h>

class TF1;
class THF1;
class THF2;
class TProfile;
class AliRhoParameter;
class AliLocalRhoParameter;
class TClonesArray;

class AliAnalysisTaskJetMatching : public AliAnalysisTaskEmcalJet
{
    public:
        // enumerators
        enum matchingSceme      {kGeoEtaPhi, kGeoR};
        enum sourceBKG          {kNoSourceBKG, kSourceRho, kSourceLocalRho};
        enum targetBKG          {kNoTargetBKG, kTargetRho, kTargetLocalRho};
        // constructors, destructor
                                AliAnalysisTaskJetMatching();
                                AliAnalysisTaskJetMatching(const char *name);
        virtual                 ~AliAnalysisTaskJetMatching();
        // setting up the task and technical aspects
        void                    ExecOnce();
        virtual void            UserCreateOutputObjects();
        TH1F*                   BookTH1F(const char* name, const char* x, Int_t bins, Double_t min, Double_t max, Bool_t append = kTRUE);
        TH2F*                   BookTH2F(const char* name, const char* x, const char* y, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Bool_t append = kTRUE);
        virtual Bool_t          Run();
        /* inline */    Double_t PhaseShift(Double_t x) const {  
            while (x>=TMath::TwoPi())x-=TMath::TwoPi();
            while (x<0.)x+=TMath::TwoPi();
            return x; }
        /* inline */    Double_t PhaseShift(Double_t x, Double_t n) const {
            x = PhaseShift(x);
            if(TMath::Nint(n)==2) while (x>TMath::Pi()) x-=TMath::Pi();
            if(TMath::Nint(n)==3) {
                if(x>2.*TMath::TwoPi()/n) x = TMath::TwoPi() - x;
                if(x>TMath::TwoPi()/n) x = TMath::TwoPi()-(x+TMath::TwoPi()/n);
            }
            return x; }
        /* inline */    Bool_t CompareTracks(AliVParticle* a, AliVParticle* b) const {
            return (TMath::AreEqualAbs(a->Pt(), b->Pt(), 1e-2) && TMath::AreEqualAbs(a->Eta(), b->Eta(), 1e-2) && TMath::AreEqualAbs(a->Phi(), b->Phi(), 1e-2)) ? kTRUE : kFALSE; }
        /* inline */    Double_t GetR(AliVParticle* a, AliVParticle* b) const {
               if(!(a&&b)) return 999;
               Double_t phiA(a->Phi()), phiB(b->Phi()), etaA(a->Eta()), etaB(b->Eta());
               if(TMath::Abs(phiA-phiB) > TMath::Abs(phiA-phiB + TMath::TwoPi())) phiA+=TMath::TwoPi();
               if(TMath::Abs(phiA-phiB) > TMath::Abs(phiA-phiB - TMath::TwoPi())) phiA-=TMath::TwoPi();
               return TMath::Sqrt(TMath::Abs((etaA-etaB)*(etaA-etaB)+(phiA-phiB)*(phiA-phiB))); }

        // setters - setup how to run
        void                    SetDebugMode(Int_t d)                           {fDebug = d;}
        void                    SetMatchingScheme(matchingSceme m)              {fMatchingScheme = m;}
        void                    SetMatchConstituents(Bool_t m)                  {fMatchConstituents = m;}
        void                    SetMinFracRecoveredConstituents(Float_t f)      {fMinFracRecoveredConstituents = f;}
        void                    SetMinFracRecoveredConstituentPt(Float_t f)     {fMinFracRecoveredConstituentPt = f;}
        void                    SetUseEmcalBaseJetCuts(Bool_t b)                {fUseEmcalBaseJetCuts = b;}
        void                    SetGetBijection(Bool_t b)                       {fGetBijection = b;}
        void                    SetSourceBKG(sourceBKG b)                       {fSourceBKG = b;}
        void                    SetTargetBKG(targetBKG b)                       {fTargetBKG = b;}
        void                    SetSourceJetsName(const char* n)                {fSourceJetsName = n;}
        void                    SetTargetJetsName(const char* n)                {fTargetJetsName = n; }
        void                    SetMatchedJetsName(const char* n)               {fMatchedJetsName = n;}
        void                    SetSourceLocalRhoName(const char* n)            {fSourceRhoName = n;}
        void                    SetTargetLocalRhoName(const char* n)            {fTargetRhoName = n;}
        void                    SetSourceRadius(Float_t r)                      {fSourceRadius = r;}
        void                    SetTargetRadius(Float_t r)                      {fTargetRadius = r;}
        void                    SetMatchEta(Float_t f)                          {fMatchEta = f;}
        void                    SetMatchPhi(Float_t f)                          {fMatchPhi = f;}
        void                    SetMatchR(Float_t f)                            {fMatchR = f;}
        void                    SetDoDetectorResponse(Bool_t d)                 {fDoDetectorResponse = d;}
        // methods
        void                    DoGeometricMatchingEtaPhi();
        void                    DoGeometricMatchingR();
        void                    DoConstituentMatching();
        void                    GetBijection();
        void                    PostMatchedJets();
        // fill histogrmas
        void                    FillAnalysisSummaryHistogram() const;
        void                    FillMatchedJetHistograms();
        // setters - analysis details
        /* inline */    Bool_t PassesCuts(const AliVTrack* track) const {
            return (!track || TMath::Abs(track->Eta()) > 0.9 || track->Phi() < 0 || track->Phi() > TMath::TwoPi()) ? kFALSE : kTRUE; }
        /* inline */    Bool_t PassesCuts(AliEmcalJet* jet) const { return (jet) ? kTRUE : kFALSE; }
        /* inline */    void ClearMatchedJetsCache() {
            for (Int_t i(0); i < fNoMatchedJets; i++) {
                fMatchedJetContainer[i][0] = 0x0; fMatchedJetContainer[i][1] = 0x0; }
            fNoMatchedJets = 0;
        }
        void                    PrintInfo() const;
        virtual void            Terminate(Option_t* option);

    private: 
        Int_t                   fDebug;                 // debug level (0 none, 1 fcn calls, 2 verbose)
        TClonesArray*           fSourceJets;            //! array with source jets
        TString                 fSourceJetsName;        // name of array with source jets
        TClonesArray*           fTargetJets;            //! array with target jets
        TString                 fTargetJetsName;        // name of array with target jets
        TClonesArray*           fMatchedJets;           //! final list of matched jets which is added to event
        TString                 fMatchedJetsName;       // name of list of matched jets
        AliLocalRhoParameter*   fSourceRho;             //! source rho
        TString                 fSourceRhoName;         // source rho  name
        AliLocalRhoParameter*   fTargetRho;             //! target rho
        TString                 fTargetRhoName;         // target rho name
        Bool_t                  fUseScaledRho;          // use scaled rho
        Float_t                 fSourceRadius;          // source radius 
        Float_t                 fTargetRadius;          // target radius
        matchingSceme           fMatchingScheme;        // select your favorite matching algorithm
        Bool_t                  fUseEmcalBaseJetCuts;   // use the emcal jet base class for jet cuts
        sourceBKG               fSourceBKG;             // subtracted background of source jets
        targetBKG               fTargetBKG;             // subtracted background of target jets
        // transient object pointers
        TList*                  fOutputList;            //! output list
        TH1F*                   fHistUnsortedCorrelation;       //! dphi correlation of unsorted jets
        TH1F*                   fHistMatchedCorrelation;        //! dphi correlation of matched jets
        TH1F*                   fHistSourceJetPt;       //! pt of source jets
        TH1F*                   fHistMatchedSourceJetPt;//! pt of matched source jets
        TH1F*                   fHistTargetJetPt;       //! pt of target jets
        TH1F*                   fHistMatchedJetPt;      //! pt of matched jets
        TH2F*                   fHistSourceMatchedJetPt;//! pt or source vs matched jets
        TH1F*                   fHistNoConstSourceJet;  //! number of constituents of source jet
        TH1F*                   fHistNoConstTargetJet;  //! number of constituents of target jet
        TH1F*                   fHistNoConstMatchJet;   //! number of constituents of matched jets
        TProfile*               fProfFracPtMatched;     //! sum pt fraction for matched tracks / jet
        TProfile*               fProfFracPtJets;        //! sum pt fraction for matched jets
        TProfile*               fProfFracNoMatched;     //! no of constituents fraction found / jet
        TProfile*               fProfFracNoJets;        //! no of consstituents fraction jet / jet
        TH1F*                   fHistAnalysisSummary;   //! flags
        TProfile*               fProfQAMatched;         //! QA spreads of matched jets
        TProfile*               fProfQA;                //! QA spreads of source and target jets
        Int_t                   fNoMatchedJets;         //! number of matched jets
        AliEmcalJet*            fMatchedJetContainer[200][2];   //! pointers to matched jets
        // geometric matching parameters
        Float_t                 fMatchEta;              // max eta distance between centers of matched jets
        Float_t                 fMatchPhi;              // max phi distance between centers of matched jets
        Float_t                 fMatchR;                // max distance between matched jets
        Bool_t                  fDoDetectorResponse;    // get detector response matrix (not normalized)
        Bool_t                  fMatchConstituents;     // match constituents
        Float_t                 fMinFracRecoveredConstituents;  // minimium fraction of constituents that needs to be found
        Float_t                 fMinFracRecoveredConstituentPt; // minimium fraction of constituent pt that needs to be recovered
        Bool_t                  fGetBijection;          // get bijection of source and matched jets

        AliAnalysisTaskJetMatching(const AliAnalysisTaskJetMatching&);                  // not implemented
        AliAnalysisTaskJetMatching& operator=(const AliAnalysisTaskJetMatching&);       // not implemented

        ClassDef(AliAnalysisTaskJetMatching, 4);
};

#endif
Commit	Line	Data
f1354962	1	#ifndef AliAnalysisTaskJetMatching_H
	2	#define AliAnalysisTaskJetMatching_H
	3
9239b066	4	#include <AliAnalysisTaskEmcalJet.h>
f1354962	5	#include <AliEmcalJet.h>
	6	#include <AliVTrack.h>
	7	#include <TClonesArray.h>
	8	#include <TMath.h>
	9	#include <TRandom3.h>
	10
	11	class TF1;
	12	class THF1;
	13	class THF2;
	14	class TProfile;
	15	class AliRhoParameter;
	16	class AliLocalRhoParameter;
	17	class TClonesArray;
	18
9239b066	19	class AliAnalysisTaskJetMatching : public AliAnalysisTaskEmcalJet
f1354962	20	{
	21	public:
	22	// enumerators
285db795	23	enum matchingSceme {kGeoEtaPhi, kGeoR};
f1354962	24	enum sourceBKG {kNoSourceBKG, kSourceRho, kSourceLocalRho};
	25	enum targetBKG {kNoTargetBKG, kTargetRho, kTargetLocalRho};
	26	// constructors, destructor
	27	AliAnalysisTaskJetMatching();
	28	AliAnalysisTaskJetMatching(const char *name);
	29	virtual ~AliAnalysisTaskJetMatching();
	30	// setting up the task and technical aspects
	31	void ExecOnce();
	32	virtual void UserCreateOutputObjects();
	33	TH1F* BookTH1F(const char* name, const char* x, Int_t bins, Double_t min, Double_t max, Bool_t append = kTRUE);
	34	TH2F* BookTH2F(const char* name, const char* x, const char* y, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Bool_t append = kTRUE);
	35	virtual Bool_t Run();
	36	/* inline */ Double_t PhaseShift(Double_t x) const {
	37	while (x>=TMath::TwoPi())x-=TMath::TwoPi();
	38	while (x<0.)x+=TMath::TwoPi();
	39	return x; }
	40	/* inline */ Double_t PhaseShift(Double_t x, Double_t n) const {
	41	x = PhaseShift(x);
	42	if(TMath::Nint(n)==2) while (x>TMath::Pi()) x-=TMath::Pi();
	43	if(TMath::Nint(n)==3) {
	44	if(x>2.*TMath::TwoPi()/n) x = TMath::TwoPi() - x;
	45	if(x>TMath::TwoPi()/n) x = TMath::TwoPi()-(x+TMath::TwoPi()/n);
	46	}
	47	return x; }
	48	/* inline / Bool_t CompareTracks(AliVParticle a, AliVParticle* b) const {
f1354962	49	return (TMath::AreEqualAbs(a->Pt(), b->Pt(), 1e-2) && TMath::AreEqualAbs(a->Eta(), b->Eta(), 1e-2) && TMath::AreEqualAbs(a->Phi(), b->Phi(), 1e-2)) ? kTRUE : kFALSE; }
f6d1b1a7	50	/* inline / Double_t GetR(AliVParticle a, AliVParticle* b) const {
	51	if(!(a&&b)) return 999;
	52	Double_t phiA(a->Phi()), phiB(b->Phi()), etaA(a->Eta()), etaB(b->Eta());
	53	if(TMath::Abs(phiA-phiB) > TMath::Abs(phiA-phiB + TMath::TwoPi())) phiA+=TMath::TwoPi();
	54	if(TMath::Abs(phiA-phiB) > TMath::Abs(phiA-phiB - TMath::TwoPi())) phiA-=TMath::TwoPi();
	55	return TMath::Sqrt(TMath::Abs((etaA-etaB)(etaA-etaB)+(phiA-phiB)(phiA-phiB))); }
f1354962	56
	57	// setters - setup how to run
	58	void SetDebugMode(Int_t d) {fDebug = d;}
	59	void SetMatchingScheme(matchingSceme m) {fMatchingScheme = m;}
f6d1b1a7	60	void SetMatchConstituents(Bool_t m) {fMatchConstituents = m;}
f6d1b1a7	61	void SetMinFracRecoveredConstituents(Float_t f) {fMinFracRecoveredConstituents = f;}
285db795	62	void SetMinFracRecoveredConstituentPt(Float_t f) {fMinFracRecoveredConstituentPt = f;}
0aaf31ab	63	void SetUseEmcalBaseJetCuts(Bool_t b) {fUseEmcalBaseJetCuts = b;}
285db795	64	void SetGetBijection(Bool_t b) {fGetBijection = b;}
f1354962	65	void SetSourceBKG(sourceBKG b) {fSourceBKG = b;}
	66	void SetTargetBKG(targetBKG b) {fTargetBKG = b;}
	67	void SetSourceJetsName(const char* n) {fSourceJetsName = n;}
	68	void SetTargetJetsName(const char* n) {fTargetJetsName = n; }
	69	void SetMatchedJetsName(const char* n) {fMatchedJetsName = n;}
f6d1b1a7	70	void SetSourceLocalRhoName(const char* n) {fSourceRhoName = n;}
	71	void SetTargetLocalRhoName(const char* n) {fTargetRhoName = n;}
	72	void SetSourceRadius(Float_t r) {fSourceRadius = r;}
	73	void SetTargetRadius(Float_t r) {fTargetRadius = r;}
f1354962	74	void SetMatchEta(Float_t f) {fMatchEta = f;}
	75	void SetMatchPhi(Float_t f) {fMatchPhi = f;}
	76	void SetMatchR(Float_t f) {fMatchR = f;}
c2460f8a	77	void SetDoDetectorResponse(Bool_t d) {fDoDetectorResponse = d;}
f1354962	78	// methods
285db795	79	void DoGeometricMatchingEtaPhi();
	80	void DoGeometricMatchingR();
	81	void DoConstituentMatching();
	82	void GetBijection();
f1354962	83	void PostMatchedJets();
	84	// fill histogrmas
	85	void FillAnalysisSummaryHistogram() const;
c2460f8a	86	void FillMatchedJetHistograms();
f1354962	87	// setters - analysis details
f1354962	88	/* inline / Bool_t PassesCuts(const AliVTrack track) const {
e9c2d4f3	89	return (!track \|\| TMath::Abs(track->Eta()) > 0.9 \|\| track->Phi() < 0 \|\| track->Phi() > TMath::TwoPi()) ? kFALSE : kTRUE; }
e9c2d4f3	90	/* inline / Bool_t PassesCuts(AliEmcalJet jet) const { return (jet) ? kTRUE : kFALSE; }
f1354962	91	/* inline */ void ClearMatchedJetsCache() {
	92	for (Int_t i(0); i < fNoMatchedJets; i++) {
	93	fMatchedJetContainer[i][0] = 0x0; fMatchedJetContainer[i][1] = 0x0; }
	94	fNoMatchedJets = 0;
	95	}
	96	void PrintInfo() const;
	97	virtual void Terminate(Option_t* option);
	98
	99	private:
	100	Int_t fDebug; // debug level (0 none, 1 fcn calls, 2 verbose)
	101	TClonesArray* fSourceJets; //! array with source jets
	102	TString fSourceJetsName; // name of array with source jets
	103	TClonesArray* fTargetJets; //! array with target jets
	104	TString fTargetJetsName; // name of array with target jets
	105	TClonesArray* fMatchedJets; //! final list of matched jets which is added to event
	106	TString fMatchedJetsName; // name of list of matched jets
f6d1b1a7	107	AliLocalRhoParameter* fSourceRho; //! source rho
	108	TString fSourceRhoName; // source rho name
	109	AliLocalRhoParameter* fTargetRho; //! target rho
	110	TString fTargetRhoName; // target rho name
f1354962	111	Bool_t fUseScaledRho; // use scaled rho
f6d1b1a7	112	Float_t fSourceRadius; // source radius
f6d1b1a7	113	Float_t fTargetRadius; // target radius
f1354962	114	matchingSceme fMatchingScheme; // select your favorite matching algorithm
0aaf31ab	115	Bool_t fUseEmcalBaseJetCuts; // use the emcal jet base class for jet cuts
f1354962	116	sourceBKG fSourceBKG; // subtracted background of source jets
f1354962	117	targetBKG fTargetBKG; // subtracted background of target jets
f1354962	118	// transient object pointers
	119	TList* fOutputList; //! output list
	120	TH1F* fHistUnsortedCorrelation; //! dphi correlation of unsorted jets
	121	TH1F* fHistMatchedCorrelation; //! dphi correlation of matched jets
	122	TH1F* fHistSourceJetPt; //! pt of source jets
2e3ee924	123	TH1F* fHistMatchedSourceJetPt;//! pt of matched source jets
f1354962	124	TH1F* fHistTargetJetPt; //! pt of target jets
f1354962	125	TH1F* fHistMatchedJetPt; //! pt of matched jets
c2460f8a	126	TH2F* fHistSourceMatchedJetPt;//! pt or source vs matched jets
f1354962	127	TH1F* fHistNoConstSourceJet; //! number of constituents of source jet
	128	TH1F* fHistNoConstTargetJet; //! number of constituents of target jet
	129	TH1F* fHistNoConstMatchJet; //! number of constituents of matched jets
0aaf31ab	130	TProfile* fProfFracPtMatched; //! sum pt fraction for matched tracks / jet
	131	TProfile* fProfFracPtJets; //! sum pt fraction for matched jets
	132	TProfile* fProfFracNoMatched; //! no of constituents fraction found / jet
	133	TProfile* fProfFracNoJets; //! no of consstituents fraction jet / jet
f1354962	134	TH1F* fHistAnalysisSummary; //! flags
	135	TProfile* fProfQAMatched; //! QA spreads of matched jets
	136	TProfile* fProfQA; //! QA spreads of source and target jets
	137	Int_t fNoMatchedJets; //! number of matched jets
c2460f8a	138	AliEmcalJet* fMatchedJetContainer[200][2]; //! pointers to matched jets
f1354962	139	// geometric matching parameters
	140	Float_t fMatchEta; // max eta distance between centers of matched jets
	141	Float_t fMatchPhi; // max phi distance between centers of matched jets
	142	Float_t fMatchR; // max distance between matched jets
c2460f8a	143	Bool_t fDoDetectorResponse; // get detector response matrix (not normalized)
f6d1b1a7	144	Bool_t fMatchConstituents; // match constituents
f6d1b1a7	145	Float_t fMinFracRecoveredConstituents; // minimium fraction of constituents that needs to be found
285db795	146	Float_t fMinFracRecoveredConstituentPt; // minimium fraction of constituent pt that needs to be recovered
285db795	147	Bool_t fGetBijection; // get bijection of source and matched jets
f1354962	148
	149	AliAnalysisTaskJetMatching(const AliAnalysisTaskJetMatching&); // not implemented
	150	AliAnalysisTaskJetMatching& operator=(const AliAnalysisTaskJetMatching&); // not implemented
	151
f6d1b1a7	152	ClassDef(AliAnalysisTaskJetMatching, 4);
f1354962	153	};
	154
	155	#endif