[u/mrichter/AliRoot.git] / PWGPP / ITS / AliAnalysisTaskITSsaTracks.h

#ifndef ALIANALYSISTASKITSSATRACKS
#define ALIANALYSISTASKITSSATRACKS

/* Copyright(c) 1998-2012, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//*************************************************************************
// Class AliAnalysisTaskITSsaTracks
// AliAnalysisTaskSE to extract QA and performance histos for ITS standalone tracks
// 
//
// Authors: L. Milano, milano@to.infn.it
//          F. Prino, prino@to.infn.it
//          
//*************************************************************************

class TList;
class TNtuple;
class TH1F;
class TH2F;
class TTree;
class TString;
class AliESDEvent;
class AliESDfriend;

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskITSsaTracks : public AliAnalysisTaskSE {

 public:
  
  AliAnalysisTaskITSsaTracks();
  virtual ~AliAnalysisTaskITSsaTracks();

  virtual void   UserExec(Option_t *option);
  virtual void   UserCreateOutputObjects();
  virtual void   Terminate(Option_t *option);

  void SetMinITSPoints(Int_t minp=4){
    fMinITSpts=minp;
  }
  void SetMinTPCPoints(Int_t minp=50){
    fMinTPCpts=minp;
  }
  void SetMinSPDPoints(Int_t minp=1){
    fMinSPDpts=minp;
  }
  void SetMinPointsForITSPid(Int_t minp=3){
    fMinPtsforPid=minp;
  }
  void SetITChi2Cut(Float_t maxchi2=2.5){
    fMaxITSChi2Clu=maxchi2;
  }

  void SetPtBins(Int_t n, Double_t* lim);

  void RequirePointInLayer(Int_t iLay){
    if(iLay<6) fRequirePoint[iLay]=kTRUE;
  }
  void RequireInnerSPD(){
    fRequirePoint[0]=kTRUE;
  }
  void RequireBothSPD(){
    fRequirePoint[0]=kTRUE;
    fRequirePoint[1]=kTRUE;
  }

  void SetFillNtuple(Bool_t fill=kTRUE){
    fFillNtuple=fill;
  }  
  void SetReadMC(Bool_t optMC=kTRUE){
    fReadMC=optMC;
  }
  void SetUseMCtruthForPID(Bool_t opt=kTRUE){
    fUseMCId=opt;
  }


 private:
  enum {kPion=0,kKaon,kProton,kNspecies};
  enum {kTypeTPCITS=0, kTypeITSsa, kTypeITSpureSA, kNtrackTypes};
  enum {kMaxPtBins=40};

  AliAnalysisTaskITSsaTracks(const AliAnalysisTaskITSsaTracks &source);
  AliAnalysisTaskITSsaTracks& operator=(const AliAnalysisTaskITSsaTracks &source);
  
  TList*  fOutput;          //! list of output histos
  TH1F*   fHistNEvents;     //! histo with N of events  

  
  TH1F*   fHistPt[kNtrackTypes];          //! pt distr., no PID
  TH1F*   fHistPtGood[kNtrackTypes];      //! pt distr. good tracks, no PID
  TH1F*   fHistPtFake[kNtrackTypes];      //! pt distr. fake tracks, no PID

  TH2F*   fHistEtaPhi[kNtrackTypes];      //! etaphi distr., no PID
  TH2F*   fHistEtaPhiGood[kNtrackTypes];  //! etaphi distr. good tracks, no PID
  TH2F*   fHistEtaPhiFake[kNtrackTypes];  //! etaphi distr. fake tracks, no PID

  TH2F*   fHistEtaPhiAny[kNtrackTypes];   //! etaphi distr., no PID, no ITS requirements
  TH2F*   fHistEtaPhi1SPD[kNtrackTypes];  //! etaphi distr., no PID, at least 1 SPD
  TH2F*   fHistEtaPhi4Clu[kNtrackTypes];  //! etaphi distr., no PID, 1SPD+ 3 dEdx
  TH2F*   fHistEtaPhi6Clu[kNtrackTypes];  //! etaphi distr., no PID, 6 Clu

  TH1F*   fHistChi2[kNtrackTypes];        //! chi2 distr., no PID
  TH1F*   fHistChi2Good[kNtrackTypes];    //! chi2 distr., good tracks, no PID
  TH1F*   fHistChi2Fake[kNtrackTypes];    //! chi2 distr., fake tracks, no PID

  TH1F*   fHistNclu[kNtrackTypes];        //! ITS clu distr., no PID
  TH1F*   fHistNcluGood[kNtrackTypes];    //! ITS clu distr., good tracks, no PID
  TH1F*   fHistNcluFake[kNtrackTypes];    //! ITS clu distr., fake tracks, no PID

  TH2F*   fHistdedxvsP2cls[kNtrackTypes]; //! dedx vs. p for tracks with 2 clus in SDD+SSD
  TH2F*   fHistdedxvsP3cls[kNtrackTypes]; //! dedx vs. p for tracks with 3 clus in SDD+SSD
  TH2F*   fHistdedxvsP4cls[kNtrackTypes]; //! dedx vs. p for tracks with 4 clus in SDD+SSD


  TH1F*   fHistPtTPCITS[kNspecies];    //! pt distribution of TPC+ITS tracks
  TH1F*   fHistPtITSsa[kNspecies];     //! pt distribution of ITSsa tracks
  TH1F*   fHistPtITSpureSA[kNspecies]; //! pt distribution of ITS pure SA tracks

  TH2F*   fHistEtaPhiTPCITS[kNspecies];    //! etaphi distr. of TPC+ITS tracks
  TH2F*   fHistEtaPhiITSsa[kNspecies];     //! etaphi distr. of ITSsa tracks
  TH2F*   fHistEtaPhiITSpureSA[kNspecies]; //! etaphi distr. of ITSpureSA tracks

  TH2F*   fHistNcluTPCITS[kNspecies];    //! n. of clusters for TPC+ITS tracks vs. pt
  TH2F*   fHistNcluITSsa[kNspecies];     //! n. of clusters for ITSsa tracks vs. pt
  TH2F*   fHistNcluITSpureSA[kNspecies]; //! n. of clusters for ITSpureSA tracks vs. pt
  TH2F*   fHistd0rphiITSpureSA[kNspecies]; //! d0z for ITSpureSA tracks vs. pt
  TH2F*   fHistd0zITSpureSA[kNspecies]; //! d0z for ITSpureSA tracks vs. pt
  TH2F*   fHistCluInLayTPCITS[kNspecies];    //! TPC+ITS tracks with cluster in layer 
  TH2F*   fHistCluInLayITSsa[kNspecies];     //! ITSsa tracks with cluster in layer 
  TH2F*   fHistCluInLayITSpureSA[kNspecies]; //! for ITSpureSA tracks with cluster in layer

  TH2F*   fHistOuterLayITSpureSA[kNspecies]; //! outer layer with cluster vs. pt

  TH2F*   fHistPtResid[kNspecies];         //! pt residuals (TPC) in pt bins
  TH2F*   fHistPtRelResid[kNspecies];      //! pt relative residuals (TPC) in pt bins
  TH2F*   fHistInvPtResid[kNspecies];      //! 1/pt residuals (TPC) in pt bins
  TH2F*   fHistInvPtRelResid[kNspecies];   //! 1/pt relative resid. (TPC) in pt bins
  TH2F*   fHistMCPtResid[kNspecies];       //! pt residuals (MC) vs. pt     
  TH2F*   fHistMCPtRelResid[kNspecies];    //! pt relative residuals (MC) vs. pt     
  TH2F*   fHistMCInvPtResid[kNspecies];    //! 1/pt residuals (MC) vs. pt
  TH2F*   fHistMCInvPtRelResid[kNspecies]; //! 1/pt relative residulas (MC) vs. pt

  TH2F*   fHistMCPhiResid; //! phi residuals in pt bins
  TH2F*   fHistPhiResid;   //! phi residuals in pt bins
  TNtuple* fNtupleTracks;  //! output ntuple

  Int_t   fNPtBins;                  // number of Pt bins
  Float_t fPtLimits[kMaxPtBins+1]; // Pt bin limits
  Int_t   fMinITSpts;       // Minimum number of ITS points per track
  Int_t   fMinSPDpts;       // Minimum number of SPD points per track
  Int_t   fMinPtsforPid;    // Minimum number of SDD+SSD points per track
  Int_t   fMinTPCpts;       // Minimum number of TPC points per track
  Float_t fMaxITSChi2Clu;   // Maximum value of ITS chi2 per cluster
  Bool_t  fRequirePoint[6]; // require point in given layer
  Bool_t  fFillNtuple;      // flag to control fill of ntuple  
  Bool_t  fReadMC;          // flag read/not-read MC truth info
  Bool_t  fUseMCId;         // flag use/not-use MC identity for PID

  ClassDef(AliAnalysisTaskITSsaTracks,3);  
};


#endif
Commit	Line	Data
045571a6	1	#ifndef ALIANALYSISTASKITSSATRACKS
	2	#define ALIANALYSISTASKITSSATRACKS
	3
	4	/* Copyright(c) 1998-2012, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	//*************************************************************************
	8	// Class AliAnalysisTaskITSsaTracks
	9	// AliAnalysisTaskSE to extract QA and performance histos for ITS standalone tracks
	10	//
	11	//
	12	// Authors: L. Milano, milano@to.infn.it
	13	// F. Prino, prino@to.infn.it
	14	//
	15	//*************************************************************************
	16
	17	class TList;
2afdea69	18	class TNtuple;
045571a6	19	class TH1F;
	20	class TH2F;
	21	class TTree;
	22	class TString;
	23	class AliESDEvent;
	24	class AliESDfriend;
	25
	26	#include "AliAnalysisTaskSE.h"
	27
	28	class AliAnalysisTaskITSsaTracks : public AliAnalysisTaskSE {
	29
	30	public:
	31
	32	AliAnalysisTaskITSsaTracks();
	33	virtual ~AliAnalysisTaskITSsaTracks();
	34
	35	virtual void UserExec(Option_t *option);
	36	virtual void UserCreateOutputObjects();
	37	virtual void Terminate(Option_t *option);
	38
	39	void SetMinITSPoints(Int_t minp=4){
	40	fMinITSpts=minp;
	41	}
	42	void SetMinTPCPoints(Int_t minp=50){
	43	fMinTPCpts=minp;
	44	}
	45	void SetMinSPDPoints(Int_t minp=1){
	46	fMinSPDpts=minp;
	47	}
	48	void SetMinPointsForITSPid(Int_t minp=3){
2afdea69	49	fMinPtsforPid=minp;
045571a6	50	}
2afdea69	51	void SetITChi2Cut(Float_t maxchi2=2.5){
2afdea69	52	fMaxITSChi2Clu=maxchi2;
045571a6	53	}
	54
	55	void SetPtBins(Int_t n, Double_t* lim);
	56
	57	void RequirePointInLayer(Int_t iLay){
	58	if(iLay<6) fRequirePoint[iLay]=kTRUE;
	59	}
	60	void RequireInnerSPD(){
	61	fRequirePoint[0]=kTRUE;
	62	}
	63	void RequireBothSPD(){
	64	fRequirePoint[0]=kTRUE;
	65	fRequirePoint[1]=kTRUE;
	66	}
	67
2afdea69	68	void SetFillNtuple(Bool_t fill=kTRUE){
	69	fFillNtuple=fill;
	70	}
045571a6	71	void SetReadMC(Bool_t optMC=kTRUE){
	72	fReadMC=optMC;
	73	}
	74	void SetUseMCtruthForPID(Bool_t opt=kTRUE){
	75	fUseMCId=opt;
	76	}
	77
	78
	79	private:
	80	enum {kPion=0,kKaon,kProton,kNspecies};
2afdea69	81	enum {kTypeTPCITS=0, kTypeITSsa, kTypeITSpureSA, kNtrackTypes};
045571a6	82	enum {kMaxPtBins=40};
	83
	84	AliAnalysisTaskITSsaTracks(const AliAnalysisTaskITSsaTracks &source);
	85	AliAnalysisTaskITSsaTracks& operator=(const AliAnalysisTaskITSsaTracks &source);
	86
	87	TList* fOutput; //! list of output histos
	88	TH1F* fHistNEvents; //! histo with N of events
	89
2afdea69	90
	91	TH1F* fHistPt[kNtrackTypes]; //! pt distr., no PID
	92	TH1F* fHistPtGood[kNtrackTypes]; //! pt distr. good tracks, no PID
	93	TH1F* fHistPtFake[kNtrackTypes]; //! pt distr. fake tracks, no PID
	94
	95	TH2F* fHistEtaPhi[kNtrackTypes]; //! etaphi distr., no PID
	96	TH2F* fHistEtaPhiGood[kNtrackTypes]; //! etaphi distr. good tracks, no PID
	97	TH2F* fHistEtaPhiFake[kNtrackTypes]; //! etaphi distr. fake tracks, no PID
	98
519eed9b	99	TH2F* fHistEtaPhiAny[kNtrackTypes]; //! etaphi distr., no PID, no ITS requirements
	100	TH2F* fHistEtaPhi1SPD[kNtrackTypes]; //! etaphi distr., no PID, at least 1 SPD
	101	TH2F* fHistEtaPhi4Clu[kNtrackTypes]; //! etaphi distr., no PID, 1SPD+ 3 dEdx
	102	TH2F* fHistEtaPhi6Clu[kNtrackTypes]; //! etaphi distr., no PID, 6 Clu
	103
2afdea69	104	TH1F* fHistChi2[kNtrackTypes]; //! chi2 distr., no PID
	105	TH1F* fHistChi2Good[kNtrackTypes]; //! chi2 distr., good tracks, no PID
	106	TH1F* fHistChi2Fake[kNtrackTypes]; //! chi2 distr., fake tracks, no PID
	107
	108	TH1F* fHistNclu[kNtrackTypes]; //! ITS clu distr., no PID
	109	TH1F* fHistNcluGood[kNtrackTypes]; //! ITS clu distr., good tracks, no PID
	110	TH1F* fHistNcluFake[kNtrackTypes]; //! ITS clu distr., fake tracks, no PID
	111
519eed9b	112	TH2F* fHistdedxvsP2cls[kNtrackTypes]; //! dedx vs. p for tracks with 2 clus in SDD+SSD
	113	TH2F* fHistdedxvsP3cls[kNtrackTypes]; //! dedx vs. p for tracks with 3 clus in SDD+SSD
	114	TH2F* fHistdedxvsP4cls[kNtrackTypes]; //! dedx vs. p for tracks with 4 clus in SDD+SSD
2afdea69	115
2afdea69	116
045571a6	117	TH1F* fHistPtTPCITS[kNspecies]; //! pt distribution of TPC+ITS tracks
	118	TH1F* fHistPtITSsa[kNspecies]; //! pt distribution of ITSsa tracks
	119	TH1F* fHistPtITSpureSA[kNspecies]; //! pt distribution of ITS pure SA tracks
	120
045571a6	121	TH2F* fHistEtaPhiTPCITS[kNspecies]; //! etaphi distr. of TPC+ITS tracks
	122	TH2F* fHistEtaPhiITSsa[kNspecies]; //! etaphi distr. of ITSsa tracks
	123	TH2F* fHistEtaPhiITSpureSA[kNspecies]; //! etaphi distr. of ITSpureSA tracks
	124
045571a6	125	TH2F* fHistNcluTPCITS[kNspecies]; //! n. of clusters for TPC+ITS tracks vs. pt
	126	TH2F* fHistNcluITSsa[kNspecies]; //! n. of clusters for ITSsa tracks vs. pt
	127	TH2F* fHistNcluITSpureSA[kNspecies]; //! n. of clusters for ITSpureSA tracks vs. pt
	128	TH2F* fHistd0rphiITSpureSA[kNspecies]; //! d0z for ITSpureSA tracks vs. pt
	129	TH2F* fHistd0zITSpureSA[kNspecies]; //! d0z for ITSpureSA tracks vs. pt
	130	TH2F* fHistCluInLayTPCITS[kNspecies]; //! TPC+ITS tracks with cluster in layer
	131	TH2F* fHistCluInLayITSsa[kNspecies]; //! ITSsa tracks with cluster in layer
	132	TH2F* fHistCluInLayITSpureSA[kNspecies]; //! for ITSpureSA tracks with cluster in layer
	133
	134	TH2F* fHistOuterLayITSpureSA[kNspecies]; //! outer layer with cluster vs. pt
	135
	136	TH2F* fHistPtResid[kNspecies]; //! pt residuals (TPC) in pt bins
	137	TH2F* fHistPtRelResid[kNspecies]; //! pt relative residuals (TPC) in pt bins
	138	TH2F* fHistInvPtResid[kNspecies]; //! 1/pt residuals (TPC) in pt bins
	139	TH2F* fHistInvPtRelResid[kNspecies]; //! 1/pt relative resid. (TPC) in pt bins
	140	TH2F* fHistMCPtResid[kNspecies]; //! pt residuals (MC) vs. pt
	141	TH2F* fHistMCPtRelResid[kNspecies]; //! pt relative residuals (MC) vs. pt
	142	TH2F* fHistMCInvPtResid[kNspecies]; //! 1/pt residuals (MC) vs. pt
	143	TH2F* fHistMCInvPtRelResid[kNspecies]; //! 1/pt relative residulas (MC) vs. pt
	144
2afdea69	145	TH2F* fHistMCPhiResid; //! phi residuals in pt bins
	146	TH2F* fHistPhiResid; //! phi residuals in pt bins
	147	TNtuple* fNtupleTracks; //! output ntuple
	148
	149	Int_t fNPtBins; // number of Pt bins
045571a6	150	Float_t fPtLimits[kMaxPtBins+1]; // Pt bin limits
2afdea69	151	Int_t fMinITSpts; // Minimum number of ITS points per track
	152	Int_t fMinSPDpts; // Minimum number of SPD points per track
	153	Int_t fMinPtsforPid; // Minimum number of SDD+SSD points per track
	154	Int_t fMinTPCpts; // Minimum number of TPC points per track
	155	Float_t fMaxITSChi2Clu; // Maximum value of ITS chi2 per cluster
045571a6	156	Bool_t fRequirePoint[6]; // require point in given layer
2afdea69	157	Bool_t fFillNtuple; // flag to control fill of ntuple
045571a6	158	Bool_t fReadMC; // flag read/not-read MC truth info
	159	Bool_t fUseMCId; // flag use/not-use MC identity for PID
	160
519eed9b	161	ClassDef(AliAnalysisTaskITSsaTracks,3);
045571a6	162	};
	163
	164
	165	#endif