[u/mrichter/AliRoot.git] / PWGCF / Correlations / DPhi / FourierDecomposition / AliDhcTask.h

// Dihadron correlations task - simple task to read ESD or AOD input,
// calculate same- and mixed-event correlations, and fill THnSparse
// output. -A. Adare, Apr 2011, updated Mar 2012

#ifndef AliDhcTask_cxx
#define AliDhcTask_cxx

#include "AliAnalysisTaskSE.h"
#include "AliPool.h"
#include "PWG/muon/AliMuonTrackCuts.h"

class TFormula;
class TH1;
class TH2;
class TH3;
class THn;
class TAxis;
class TObjArray;
class TObject;
class TProfile2D;
class AliAODEvent;
class AliAODTrack;
class AliAnalysisUtils;
class AliESDEvent;
class AliESDMuonTrack;
class AliESDtrackCuts;
class AliEvtPoolManager;

class AliDhcTask : public AliAnalysisTaskSE {
 public:
  AliDhcTask();
  AliDhcTask(const char *name, Bool_t def=kFALSE);
  virtual ~AliDhcTask();
  
  void         SetAllTAHists(Bool_t b)                { fAllTAHists = b;          }
  void         SetAnaMode(Int_t iAna);
  void         SetCentBins(TAxis *bins)               { fBCent=bins;              }
  void         SetCentMethod(const char *name)        { fCentMethod = name;       }
  void         SetCentMixBins(TAxis *bins)            { fMixBCent=bins;           }
  void         SetCheckVertex(Bool_t b)               { fCheckVertex = b;         }
  void         SetClassName(const char *n)            { fClassName = n;           }
  void         SetDEtaDPhiBins(Int_t nbe, Int_t nbp)  { fNBdeta=nbe; fNBdphi=nbp; }
  void         SetDoFillSame(Bool_t b)                { fDoFillSame = b;          }
  void         SetDoMassCut(Bool_t b)                 { fDoMassCut = b;           }
  void         SetDoWeights(Bool_t b)                 { fDoWeights = b;           }
  void         SetEtaMax(Double_t eta)                { fEtaMax = eta;            }
  void         SetEtaTRange(Double_t eL, Double_t eH) { fEtaTLo=eL; fEtaTHi=eH;   }
  void         SetEtaARange(Double_t eL, Double_t eH) { fEtaALo=eL; fEtaAHi=eH;   }
  void         SetFillMuons(Bool_t b)                 { fFillMuons = b;           }
  void         SetHEffA(THnF *h)                      { fHEffA=h;                 }
  void         SetHEffT(THnF *h)                      { fHEffT=h;                 }
  void         SetMixInEtaT(Bool_t b)                 { fMixInEtaT = b;           }
  void         SetMuonUtils(Bool_t b = kTRUE,
                            UInt_t mask = AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs | AliMuonTrackCuts::kMuPdca | AliMuonTrackCuts::kMuMatchApt ) {
    fUseMuonUtils = b;
    fMuonCutMask = mask;
  }
  void         SetOmitFirstEv(Bool_t b)               { fOmitFirstEv = b;         }
  void         SetPoolSize(Int_t p)                   { fPoolSize = p;            }
  void         SetPtABins(TAxis *bins)                { fBPtA=bins;               }
  void         SetPtRange(Double_t min, Double_t max) { fPtMin=min; fPtMax=max;   }
  void         SetPtTACrit(Bool_t b)                  { fPtTACrit = b;            }
  void         SetPtTBins(TAxis *bins)                { fBPtT=bins;               }
  void         SetRequireMuon(Bool_t b, Double_t l=0.5, Double_t h=4.0) {
    fRequireMuon = b;
    fReqPtLo = l;
    fReqPtHi = h;
  }
  void         SetTrackDepth(Int_t t)                 { fTrackDepth = t;          }
  void         SetTracksName(const char *n)           { fTracksName = n;          }
  void         SetTriggerMatch(Bool_t b)              { fTriggerMatch = b;        }
  void         SetVerbosity(Int_t v)                  { fVerbosity = v;           }
  void         SetZVtxBins(TAxis *bins)               { fBZvtx=bins;              }
  void         SetZVtxMixBins(TAxis *bins)            { fMixBZvtx=bins;           }
  void         SetZvtx(Double_t zvtx)                 { fZVtxMax = zvtx;          }
  void         PrintDhcSettings();

  enum eAnaMode       {kHH=1, kMuH, kHMu, kMuMu, kPSide, kASide};

 protected:
  enum ePairingScheme {kSameEvt, kDiffEvt};
  enum eDataType      {kESD, kAOD};

  void         BookHistos();
  void         InitEventMixer();
  void         GetESDTracks(MiniEvent*);
  void         GetAODTracks(MiniEvent*);
  Bool_t       VertexOk() const;
  Bool_t       HasMuonESD();
  Bool_t       HasMuonAOD();
  Bool_t       IsGoodMUONtrack(AliESDMuonTrack &track);
  Bool_t       IsGoodMUONtrack(AliAODTrack &track);
  Bool_t       IsTrigger(Double_t eta, Double_t pt);
  Bool_t       IsAssociated(Double_t eta, Double_t pt);
  Double_t     DeltaPhi(Double_t phia, Double_t phib,
			Double_t rangeMin = -TMath::Pi()/2, 
			Double_t rangeMax = 3*TMath::Pi()/2) const;
  Int_t        Correlate(const MiniEvent &arr1, const MiniEvent &arr2, Int_t pairing = kSameEvt);
  void         UserCreateOutputObjects();
  void         UserExec(Option_t *option);
  void         Terminate(Option_t *);

 private:
  Int_t              fVerbosity;       //  0 = silence
  Double_t           fEtaMax;          //  Max |eta| cut for standard ESD or AOD analysis
  Double_t           fZVtxMax;         //  Max |z| cut (cm)
  Double_t           fPtMin;           //  Min pt cut
  Double_t           fPtMax;           //  Max pt cut
  Int_t              fTrackDepth;      //  #tracks to fill pool
  Int_t              fPoolSize;        //  Maximum number of events
  TString            fTracksName;      //  name of track collection
  Bool_t             fDoWeights;       //  if true weight with 1/N per event
  Bool_t             fFillMuons;       //  fill the muon tracks into the mini event
  Bool_t             fRequireMuon;     //  only run on events with a muon track
  Double_t           fReqPtLo;         //  require a muon above this pt
  Double_t           fReqPtHi;         //  and below this pt
  Bool_t             fPtTACrit;        //  use the pTT > pTA criterion?
  Bool_t             fAllTAHists;      //  create all pTT,pTA combination hists, even t<a?
  Bool_t             fMixInEtaT;       //  mix in bins of eta_T instead of z_vertex
  Bool_t             fUseMuonUtils;    //  use muon cuts from PWG/muon/AliMuonTrackCuts ?
  UInt_t             fMuonCutMask;     //  muon cut mask for above
  AliMuonTrackCuts  *fMuonTrackCuts;   //  muon track cut object
  Double_t           fEtaTLo;          //  Min eta for triggers
  Double_t           fEtaTHi;          //  Max eta for triggers
  Double_t           fEtaALo;          //  Min eta for associated
  Double_t           fEtaAHi;          //  Max eta for associated
  Bool_t             fOmitFirstEv;     //  if true skip first event in chunk
  Bool_t             fDoFillSame;      //  If true fill same event immediately (not waiting for pool)
  Bool_t             fDoMassCut;       //  If true cut on invariant mass
  Bool_t             fCheckVertex;     //  switch to flase for MC generator-level analysis
  TString            fClassName;       //  If not null only process events with given class
  TString            fCentMethod;      //  centrality selection method
  Int_t              fNBdeta;          //  no. deta bins
  Int_t              fNBdphi;          //  no. dphi bins
  Bool_t             fTriggerMatch;    //  muon trigger match
  TAxis             *fBPtT;            //  ptt binning
  TAxis             *fBPtA;            //  pta binning
  TAxis             *fBCent;           //  centrality binning
  TAxis             *fBZvtx;           //  zvtx binning
  TAxis             *fMixBCent;        //  centrality binning for mixing
  TAxis             *fMixBZvtx;        //  zvtx binning for mixing
  THnF              *fHEffT;           //  efficiency for trigger particles
  THnF              *fHEffA;           //  efficiency for associate particles
  AliESDEvent       *fESD;             //! ESD object
  AliAODEvent       *fAOD;             //! AOD object
  TList             *fOutputList;      //! Output list
  TH2               *fHEvt;            //! Cent vs vtx.
  TH2               *fHEvtWTr;         //! Cent vs vtx. for events with at least one track
  TH2               *fHTrk;            //! Phi vs Eta
  TH2               *fHPoolReady;      //! Check how many Jobs start mixing
  TH1               *fHPtAss;          //! Pt ass
  TH1               *fHPtTrg;          //! Pt trg
  TH1               *fHPtTrgEvt;       //! Pt trg per event for weighting
  TH3               *fHPtTrgNorm1S;    //! Pt trg same events in cent. and zvtx bins, method 1
  TH3               *fHPtTrgNorm1M;    //! Pt trg mixed events in cent. and zvtx bins, method 1
  TH3               *fHPtTrgNorm2S;    //! Pt trg same events in cent. and zvtx bins, method 2
  TH3               *fHPtTrgNorm2M;    //! Pt trg mixed events in cent. and zvtx bins, method 2
  TH1               *fHCent;           //! Centrality
  TH1               *fHZvtx;           //! Zvertex
  Int_t              fNbins;           //! Number of histogram bins
  TH2              **fHSs;             //! Same-evt correlations
  TH2              **fHMs;             //! Diff-evt correlations
  TH1              **fHPts;            //! Pt distributions
  TH1              **fHSMass;          //! Mass distributions same
  TH1              **fHMMass;          //! Mass distributions mixed
  TH3               *fHQATp;           //! positive trigger particle distribution for QA
  TH3               *fHQAAp;           //! associated particle distribution for QA
  TH3               *fHQATpCorr;       //! correction applied trigger distribution
  TH3               *fHQAApCorr;       //! correction applied associated distribution
  TH3               *fHQATm;           //! the same for negative particles
  TH3               *fHQAAm;           //!
  TH3               *fHQATmCorr;       //!
  TH3               *fHQAAmCorr;       //!
  TH2               *fHPtCentT;        //! trigger pT vs centrality
  TH2               *fHPtCentA;        //! associated pT vs centrality
  TFormula          *fIndex;           //! index for histograms
  Double_t           fCentrality;      //! centrality of current event
  Double_t           fZVertex;         //! z vertex of current event
  AliESDtrackCuts   *fEsdTPCOnly;      //! track cuts
  AliEvtPoolManager *fPoolMgr;         //! event mixer
  AliAnalysisUtils  *fUtils;           //! analysis utils

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

  ClassDef(AliDhcTask, 9)
};

#endif
Commit	Line	Data
48a61f36	1	// Dihadron correlations task - simple task to read ESD or AOD input,
48a61f36	2	// calculate same- and mixed-event correlations, and fill THnSparse
be8a5cdb	3	// output. -A. Adare, Apr 2011, updated Mar 2012
48a61f36	4
	5	#ifndef AliDhcTask_cxx
	6	#define AliDhcTask_cxx
	7
beb13b6c	8	#include "AliAnalysisTaskSE.h"
beb13b6c	9	#include "AliPool.h"
60d8d990	10	#include "PWG/muon/AliMuonTrackCuts.h"
beb13b6c	11
be8a5cdb	12	class TFormula;
48a61f36	13	class TH1;
48a61f36	14	class TH2;
beb13b6c	15	class TH3;
b3b66a56	16	class THn;
d688e049	17	class TAxis;
48a61f36	18	class TObjArray;
be8a5cdb	19	class TObject;
be8a5cdb	20	class TProfile2D;
48a61f36	21	class AliAODEvent;
b3b66a56	22	class AliAODTrack;
b3b66a56	23	class AliAnalysisUtils;
be8a5cdb	24	class AliESDEvent;
beb13b6c	25	class AliESDMuonTrack;
b3b66a56	26	class AliESDtrackCuts;
be8a5cdb	27	class AliEvtPoolManager;
48a61f36	28
48a61f36	29	class AliDhcTask : public AliAnalysisTaskSE {
48a61f36	30	public:
beb13b6c	31	AliDhcTask();
eee08176	32	AliDhcTask(const char *name, Bool_t def=kFALSE);
b673a083	33	virtual ~AliDhcTask();
48a61f36	34
5a6df06d	35	void SetAllTAHists(Bool_t b) { fAllTAHists = b; }
5a6df06d	36	void SetAnaMode(Int_t iAna);
d688e049	37	void SetCentBins(TAxis *bins) { fBCent=bins; }
	38	void SetCentMethod(const char *name) { fCentMethod = name; }
	39	void SetCentMixBins(TAxis *bins) { fMixBCent=bins; }
60d8d990	40	void SetCheckVertex(Bool_t b) { fCheckVertex = b; }
5a6df06d	41	void SetClassName(const char *n) { fClassName = n; }
d688e049	42	void SetDEtaDPhiBins(Int_t nbe, Int_t nbp) { fNBdeta=nbe; fNBdphi=nbp; }
eee08176	43	void SetDoFillSame(Bool_t b) { fDoFillSame = b; }
98880cdf	44	void SetDoMassCut(Bool_t b) { fDoMassCut = b; }
d688e049	45	void SetDoWeights(Bool_t b) { fDoWeights = b; }
d688e049	46	void SetEtaMax(Double_t eta) { fEtaMax = eta; }
15b0d1bb	47	void SetEtaTRange(Double_t eL, Double_t eH) { fEtaTLo=eL; fEtaTHi=eH; }
a2dc255f	48	void SetEtaARange(Double_t eL, Double_t eH) { fEtaALo=eL; fEtaAHi=eH; }
5a6df06d	49	void SetFillMuons(Bool_t b) { fFillMuons = b; }
	50	void SetHEffA(THnF *h) { fHEffA=h; }
	51	void SetHEffT(THnF *h) { fHEffT=h; }
	52	void SetMixInEtaT(Bool_t b) { fMixInEtaT = b; }
60d8d990	53	void SetMuonUtils(Bool_t b = kTRUE,
	54	UInt_t mask = AliMuonTrackCuts::kMuEta \| AliMuonTrackCuts::kMuThetaAbs \| AliMuonTrackCuts::kMuPdca \| AliMuonTrackCuts::kMuMatchApt ) {
	55	fUseMuonUtils = b;
	56	fMuonCutMask = mask;
	57	}
b3b66a56	58	void SetOmitFirstEv(Bool_t b) { fOmitFirstEv = b; }
d688e049	59	void SetPoolSize(Int_t p) { fPoolSize = p; }
	60	void SetPtABins(TAxis *bins) { fBPtA=bins; }
	61	void SetPtRange(Double_t min, Double_t max) { fPtMin=min; fPtMax=max; }
5a6df06d	62	void SetPtTACrit(Bool_t b) { fPtTACrit = b; }
d688e049	63	void SetPtTBins(TAxis *bins) { fBPtT=bins; }
60d8d990	64	void SetRequireMuon(Bool_t b, Double_t l=0.5, Double_t h=4.0) {
	65	fRequireMuon = b;
	66	fReqPtLo = l;
	67	fReqPtHi = h;
	68	}
d688e049	69	void SetTrackDepth(Int_t t) { fTrackDepth = t; }
d688e049	70	void SetTracksName(const char *n) { fTracksName = n; }
f901a713	71	void SetTriggerMatch(Bool_t b) { fTriggerMatch = b; }
d688e049	72	void SetVerbosity(Int_t v) { fVerbosity = v; }
	73	void SetZVtxBins(TAxis *bins) { fBZvtx=bins; }
	74	void SetZVtxMixBins(TAxis *bins) { fMixBZvtx=bins; }
	75	void SetZvtx(Double_t zvtx) { fZVtxMax = zvtx; }
d7149d30	76	void PrintDhcSettings();
b3b66a56	77
eee08176	78	enum eAnaMode {kHH=1, kMuH, kHMu, kMuMu, kPSide, kASide};
48a61f36	79
48a61f36	80	protected:
48a61f36	81	enum ePairingScheme {kSameEvt, kDiffEvt};
be8a5cdb	82	enum eDataType {kESD, kAOD};
48a61f36	83
be8a5cdb	84	void BookHistos();
be8a5cdb	85	void InitEventMixer();
f6701c6e	86	void GetESDTracks(MiniEvent*);
f6701c6e	87	void GetAODTracks(MiniEvent*);
b3b66a56	88	Bool_t VertexOk() const;
60d8d990	89	Bool_t HasMuonESD();
60d8d990	90	Bool_t HasMuonAOD();
beb13b6c	91	Bool_t IsGoodMUONtrack(AliESDMuonTrack &track);
b673a083	92	Bool_t IsGoodMUONtrack(AliAODTrack &track);
49e33473	93	Bool_t IsTrigger(Double_t eta, Double_t pt);
49e33473	94	Bool_t IsAssociated(Double_t eta, Double_t pt);
beb13b6c	95	Double_t DeltaPhi(Double_t phia, Double_t phib,
be8a5cdb	96	Double_t rangeMin = -TMath::Pi()/2,
be8a5cdb	97	Double_t rangeMax = 3*TMath::Pi()/2) const;
d688e049	98	Int_t Correlate(const MiniEvent &arr1, const MiniEvent &arr2, Int_t pairing = kSameEvt);
be8a5cdb	99	void UserCreateOutputObjects();
	100	void UserExec(Option_t *option);
	101	void Terminate(Option_t *);
48a61f36	102
48a61f36	103	private:
8a9d3e12	104	Int_t fVerbosity; // 0 = silence
beb13b6c	105	Double_t fEtaMax; // Max \|eta\| cut for standard ESD or AOD analysis
8a9d3e12	106	Double_t fZVtxMax; // Max \|z\| cut (cm)
	107	Double_t fPtMin; // Min pt cut
	108	Double_t fPtMax; // Max pt cut
	109	Int_t fTrackDepth; // #tracks to fill pool
	110	Int_t fPoolSize; // Maximum number of events
	111	TString fTracksName; // name of track collection
beb13b6c	112	Bool_t fDoWeights; // if true weight with 1/N per event
beb13b6c	113	Bool_t fFillMuons; // fill the muon tracks into the mini event
88f09b54	114	Bool_t fRequireMuon; // only run on events with a muon track
	115	Double_t fReqPtLo; // require a muon above this pt
	116	Double_t fReqPtHi; // and below this pt
b422cf0d	117	Bool_t fPtTACrit; // use the pTT > pTA criterion?
e47b8f11	118	Bool_t fAllTAHists; // create all pTT,pTA combination hists, even t<a?
d7149d30	119	Bool_t fMixInEtaT; // mix in bins of eta_T instead of z_vertex
60d8d990	120	Bool_t fUseMuonUtils; // use muon cuts from PWG/muon/AliMuonTrackCuts ?
	121	UInt_t fMuonCutMask; // muon cut mask for above
	122	AliMuonTrackCuts *fMuonTrackCuts; // muon track cut object
beb13b6c	123	Double_t fEtaTLo; // Min eta for triggers
	124	Double_t fEtaTHi; // Max eta for triggers
	125	Double_t fEtaALo; // Min eta for associated
	126	Double_t fEtaAHi; // Max eta for associated
b3b66a56	127	Bool_t fOmitFirstEv; // if true skip first event in chunk
eee08176	128	Bool_t fDoFillSame; // If true fill same event immediately (not waiting for pool)
98880cdf	129	Bool_t fDoMassCut; // If true cut on invariant mass
ceeaa699	130	Bool_t fCheckVertex; // switch to flase for MC generator-level analysis
5a6df06d	131	TString fClassName; // If not null only process events with given class
f901a713	132	TString fCentMethod; // centrality selection method
	133	Int_t fNBdeta; // no. deta bins
	134	Int_t fNBdphi; // no. dphi bins
88f09b54	135	Bool_t fTriggerMatch; // muon trigger match
f901a713	136	TAxis *fBPtT; // ptt binning
	137	TAxis *fBPtA; // pta binning
	138	TAxis *fBCent; // centrality binning
	139	TAxis *fBZvtx; // zvtx binning
	140	TAxis *fMixBCent; // centrality binning for mixing
	141	TAxis *fMixBZvtx; // zvtx binning for mixing
	142	THnF *fHEffT; // efficiency for trigger particles
	143	THnF *fHEffA; // efficiency for associate particles
8a9d3e12	144	AliESDEvent *fESD; //! ESD object
	145	AliAODEvent *fAOD; //! AOD object
	146	TList *fOutputList; //! Output list
	147	TH2 *fHEvt; //! Cent vs vtx.
88f09b54	148	TH2 *fHEvtWTr; //! Cent vs vtx. for events with at least one track
8a9d3e12	149	TH2 *fHTrk; //! Phi vs Eta
7040ed98	150	TH2 *fHPoolReady; //! Check how many Jobs start mixing
7040ed98	151	TH1 *fHPtAss; //! Pt ass
8a9d3e12	152	TH1 *fHPtTrg; //! Pt trg
beb13b6c	153	TH1 *fHPtTrgEvt; //! Pt trg per event for weighting
	154	TH3 *fHPtTrgNorm1S; //! Pt trg same events in cent. and zvtx bins, method 1
	155	TH3 *fHPtTrgNorm1M; //! Pt trg mixed events in cent. and zvtx bins, method 1
	156	TH3 *fHPtTrgNorm2S; //! Pt trg same events in cent. and zvtx bins, method 2
	157	TH3 *fHPtTrgNorm2M; //! Pt trg mixed events in cent. and zvtx bins, method 2
8a9d3e12	158	TH1 *fHCent; //! Centrality
	159	TH1 *fHZvtx; //! Zvertex
	160	Int_t fNbins; //! Number of histogram bins
	161	TH2 **fHSs; //! Same-evt correlations
	162	TH2 **fHMs; //! Diff-evt correlations
380fb711	163	TH1 **fHPts; //! Pt distributions
98880cdf	164	TH1 **fHSMass; //! Mass distributions same
98880cdf	165	TH1 **fHMMass; //! Mass distributions mixed
21852ae0	166	TH3 *fHQATp; //! positive trigger particle distribution for QA
	167	TH3 *fHQAAp; //! associated particle distribution for QA
	168	TH3 *fHQATpCorr; //! correction applied trigger distribution
	169	TH3 *fHQAApCorr; //! correction applied associated distribution
	170	TH3 *fHQATm; //! the same for negative particles
	171	TH3 *fHQAAm; //!
	172	TH3 *fHQATmCorr; //!
	173	TH3 *fHQAAmCorr; //!
d7149d30	174	TH2 *fHPtCentT; //! trigger pT vs centrality
d7149d30	175	TH2 *fHPtCentA; //! associated pT vs centrality
f901a713	176	TFormula *fIndex; //! index for histograms
	177	Double_t fCentrality; //! centrality of current event
	178	Double_t fZVertex; //! z vertex of current event
	179	AliESDtrackCuts *fEsdTPCOnly; //! track cuts
	180	AliEvtPoolManager *fPoolMgr; //! event mixer
	181	AliAnalysisUtils *fUtils; //! analysis utils
48a61f36	182
	183	AliDhcTask(const AliDhcTask&); // not implemented
	184	AliDhcTask &operator=(const AliDhcTask&); // not implemented
	185
f901a713	186	ClassDef(AliDhcTask, 9)
48a61f36	187	};
	188
	189	#endif