[u/mrichter/AliRoot.git] / PWGUD / selectors / dNdEta / AlidNdEtaTask.h

/* $Id$ */

#ifndef AlidNdEtaTask_H
#define AlidNdEtaTask_H

#include "AliAnalysisTaskSE.h"
#include "AliPWG0Helper.h"
#include "AliTriggerAnalysis.h"
#include <TString.h>

class AliESDtrackCuts;
class dNdEtaAnalysis;
class TH1F;
class TH2F;
class TH3F;
class AliESDEvent;
class AliTriggerAnalysis;
class TH1D;

class AlidNdEtaTask : public AliAnalysisTaskSE {
  public:
    AlidNdEtaTask(const char* opt = "");
    virtual ~AlidNdEtaTask();

    virtual void   ConnectInputData(Option_t *opt);
    virtual void   UserCreateOutputObjects();
    virtual void   UserExec(Option_t*);
    virtual void   Terminate(Option_t*);
    virtual Bool_t UserNotify();
    
    Bool_t IsEventInBinZero();

    void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
    void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
    void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
    void SetUseMCVertex(Bool_t flag = kTRUE) { fUseMCVertex = flag; }
    void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
    void SetUseMCKine(Bool_t flag = kTRUE) { fUseMCKine = flag; }
    void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
    void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
    void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
    void SetSymmetrize(Bool_t flag = kTRUE) { fSymmetrize = flag; }
    void SetMultAxisEta1(Bool_t flag = kTRUE) { fMultAxisEta1 = flag; }
    void SetDiffTreatment(AliPWG0Helper::DiffTreatment diffTreatment) { fDiffTreatment = diffTreatment; }
    
    void SetOption(const char* opt) { fOption = opt; }
    void SetPtMin(Float_t ptMin) { fPtMin = ptMin;}

 protected:
    AliESDEvent *fESD;                         //! ESD object
    TList* fOutput;                            //! list send on output slot 0

    TString fOption;                           // option string
    AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
    AliTriggerAnalysis::Trigger fTrigger;      // trigger that is used
    Bool_t fFillPhi;                           // if true phi is filled as 3rd coordinate in all maps
    Float_t fDeltaPhiCut;                      // cut in delta phi (only SPD)

    Bool_t  fReadMC;          // if true reads MC data (to build correlation maps)
    Bool_t  fUseMCVertex;     // the MC vtx is used instead of the ESD vertex (for syst. check)
    Bool_t  fOnlyPrimaries;   // Process only primaries by using the MC information (for syst. check)
    Bool_t  fUseMCKine;       // use the MC values for each found track/tracklet (for syst. check)
    Bool_t  fSymmetrize;      // move all negative to positive eta
    Bool_t  fMultAxisEta1;    // restrict multiplicity count to |eta| < 1
    AliPWG0Helper::DiffTreatment  fDiffTreatment;  // how to identify SD events (see AliPWG0Helper::GetEventProcessType)

    AliESDtrackCuts* fEsdTrackCuts;         // Object containing the parameters of the esd track cuts

    // Gathered from ESD
    dNdEtaAnalysis* fdNdEtaAnalysisESD;     //! contains the dndeta from the ESD
    // control hists
    TH1F* fMult;                            //! raw multiplicity histogram
    TH1F* fMultVtx;                            //! raw multiplicity histogram of evts with vtx (control histogram)
    TH1F* fPartEta[3];            //! counted particles as function of eta (full vertex range, below 0 range, above 0 range)
    TH1F* fEvents;                //! events counted as function of vtx
    TH2F* fVertexResolution;      //! z resolution of the vertex 

    // Gathered from MC (when fReadMC is set)
    dNdEtaAnalysis* fdNdEtaAnalysis;        //! contains the dndeta from the full sample
    dNdEtaAnalysis* fdNdEtaAnalysisND;      //! contains the dndeta for the ND sample
    dNdEtaAnalysis* fdNdEtaAnalysisNSD;     //! contains the dndeta for the NSD sample
    dNdEtaAnalysis* fdNdEtaAnalysisOnePart; //! contains the dndeta for the one particle sample
    dNdEtaAnalysis* fdNdEtaAnalysisTr;      //! contains the dndeta from the triggered events
    dNdEtaAnalysis* fdNdEtaAnalysisTrVtx;   //! contains the dndeta from the triggered events with vertex
    dNdEtaAnalysis* fdNdEtaAnalysisTracks;  //! contains the dndeta from the triggered events with vertex counted from the mc particles associated to the tracks (comparing this to the raw values from the esd shows the effect of the detector resolution)

    // control histograms (MC)
    TH1F* fPartPt;                //! counted particles as function of pt

    // control histograms (ESD)
    TH3F* fVertex;                //! 3d vertex distribution
    TH3F* fVertexVsMult;          //! x-vtx vs y-vtx vs multiplicity
    TH1F* fPhi;                   //! raw phi distribution
    TH1F* fRawPt;                 //! raw pt distribution
    TH2F* fEtaPhi;                //! raw eta - phi distribution
    TH2F* fZPhi[2];               //! raw z - phi distribution from tracklets per layer (only SPD)
    TH1F* fModuleMap;             //! count clusters as function of module number (only SPD)
    TH1F* fDeltaPhi;              //! histogram of delta_phi values for tracklets (only for SPD analysis)
    TH1F* fDeltaTheta;            //! histogram of delta_theta values for tracklets (only for SPD analysis)
    TH2F* fFiredChips;            //! fired chips l1+l2 vs. number of tracklets (only for SPD analysis)
    TH2F* fTrackletsVsClusters;   //! number of tracklets vs. clusters in all ITS detectors (only for SPD analysis)
    TH2F* fTrackletsVsUnassigned; //! number of tracklets vs. number of unassigned clusters in L1 (only for SPD analysis)
    TH1F* fStats;                 //! further statistics : bin 1 = vertexer 3d, bin 2 = vertexer z, etc (see CreateOutputObjects)
    TH2F* fStats2;                //! V0 vs SPD statistics
    Float_t fPtMin;               // pt min, to be used in kOneTrack case
    TH1D* fEta;                   //! eta distribution from ESD
    TH1D* fEtaMC;                 //! eta distribution from MC
    TH1D* fHistEvents;            //! histo for n. of selected ESD events
    TH1D* fHistEventsMC;          //! histo for n. of selected MC events
    TH1D* fTrigEffNum;            //!
    TH1D* fTrigEffDen;            //!
    TH1D* fVtxEffNum;             //!
    TH1D* fVtxEffDen;             //!
    TH1D* fVtxTrigEffNum;         //!
    TH1D* fVtxTrigEffDen;         //!
 private:
    AlidNdEtaTask(const AlidNdEtaTask&);
    AlidNdEtaTask& operator=(const AlidNdEtaTask&);

  ClassDef(AlidNdEtaTask, 2);
};

#endif
Commit	Line	Data
	1	/* $Id$ */
	2
	3	#ifndef AlidNdEtaTask_H
	4	#define AlidNdEtaTask_H
	5
	6	#include "AliAnalysisTaskSE.h"
	7	#include "AliPWG0Helper.h"
	8	#include "AliTriggerAnalysis.h"
	9	#include <TString.h>
	10
	11	class AliESDtrackCuts;
	12	class dNdEtaAnalysis;
	13	class TH1F;
	14	class TH2F;
	15	class TH3F;
	16	class AliESDEvent;
	17	class AliTriggerAnalysis;
	18	class TH1D;
	19
	20	class AlidNdEtaTask : public AliAnalysisTaskSE {
	21	public:
	22	AlidNdEtaTask(const char* opt = "");
	23	virtual ~AlidNdEtaTask();
	24
	25	virtual void ConnectInputData(Option_t *opt);
	26	virtual void UserCreateOutputObjects();
	27	virtual void UserExec(Option_t*);
	28	virtual void Terminate(Option_t*);
	29	virtual Bool_t UserNotify();
	30
	31	Bool_t IsEventInBinZero();
	32
	33	void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
	34	void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
	35	void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
	36	void SetUseMCVertex(Bool_t flag = kTRUE) { fUseMCVertex = flag; }
	37	void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
	38	void SetUseMCKine(Bool_t flag = kTRUE) { fUseMCKine = flag; }
	39	void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
	40	void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
	41	void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
	42	void SetSymmetrize(Bool_t flag = kTRUE) { fSymmetrize = flag; }
	43	void SetMultAxisEta1(Bool_t flag = kTRUE) { fMultAxisEta1 = flag; }
	44	void SetDiffTreatment(AliPWG0Helper::DiffTreatment diffTreatment) { fDiffTreatment = diffTreatment; }
	45
	46	void SetOption(const char* opt) { fOption = opt; }
	47	void SetPtMin(Float_t ptMin) { fPtMin = ptMin;}
	48
	49	protected:
	50	AliESDEvent *fESD; //! ESD object
	51	TList* fOutput; //! list send on output slot 0
	52
	53	TString fOption; // option string
	54	AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
	55	AliTriggerAnalysis::Trigger fTrigger; // trigger that is used
	56	Bool_t fFillPhi; // if true phi is filled as 3rd coordinate in all maps
	57	Float_t fDeltaPhiCut; // cut in delta phi (only SPD)
	58
	59	Bool_t fReadMC; // if true reads MC data (to build correlation maps)
	60	Bool_t fUseMCVertex; // the MC vtx is used instead of the ESD vertex (for syst. check)
	61	Bool_t fOnlyPrimaries; // Process only primaries by using the MC information (for syst. check)
	62	Bool_t fUseMCKine; // use the MC values for each found track/tracklet (for syst. check)
	63	Bool_t fSymmetrize; // move all negative to positive eta
	64	Bool_t fMultAxisEta1; // restrict multiplicity count to \|eta\| < 1
	65	AliPWG0Helper::DiffTreatment fDiffTreatment; // how to identify SD events (see AliPWG0Helper::GetEventProcessType)
	66
	67	AliESDtrackCuts* fEsdTrackCuts; // Object containing the parameters of the esd track cuts
	68
	69	// Gathered from ESD
	70	dNdEtaAnalysis* fdNdEtaAnalysisESD; //! contains the dndeta from the ESD
	71	// control hists
	72	TH1F* fMult; //! raw multiplicity histogram
	73	TH1F* fMultVtx; //! raw multiplicity histogram of evts with vtx (control histogram)
	74	TH1F* fPartEta[3]; //! counted particles as function of eta (full vertex range, below 0 range, above 0 range)
	75	TH1F* fEvents; //! events counted as function of vtx
	76	TH2F* fVertexResolution; //! z resolution of the vertex
	77
	78	// Gathered from MC (when fReadMC is set)
	79	dNdEtaAnalysis* fdNdEtaAnalysis; //! contains the dndeta from the full sample
	80	dNdEtaAnalysis* fdNdEtaAnalysisND; //! contains the dndeta for the ND sample
	81	dNdEtaAnalysis* fdNdEtaAnalysisNSD; //! contains the dndeta for the NSD sample
	82	dNdEtaAnalysis* fdNdEtaAnalysisOnePart; //! contains the dndeta for the one particle sample
	83	dNdEtaAnalysis* fdNdEtaAnalysisTr; //! contains the dndeta from the triggered events
	84	dNdEtaAnalysis* fdNdEtaAnalysisTrVtx; //! contains the dndeta from the triggered events with vertex
	85	dNdEtaAnalysis* fdNdEtaAnalysisTracks; //! contains the dndeta from the triggered events with vertex counted from the mc particles associated to the tracks (comparing this to the raw values from the esd shows the effect of the detector resolution)
	86
	87	// control histograms (MC)
	88	TH1F* fPartPt; //! counted particles as function of pt
	89
	90	// control histograms (ESD)
	91	TH3F* fVertex; //! 3d vertex distribution
	92	TH3F* fVertexVsMult; //! x-vtx vs y-vtx vs multiplicity
	93	TH1F* fPhi; //! raw phi distribution
	94	TH1F* fRawPt; //! raw pt distribution
	95	TH2F* fEtaPhi; //! raw eta - phi distribution
	96	TH2F* fZPhi[2]; //! raw z - phi distribution from tracklets per layer (only SPD)
	97	TH1F* fModuleMap; //! count clusters as function of module number (only SPD)
	98	TH1F* fDeltaPhi; //! histogram of delta_phi values for tracklets (only for SPD analysis)
	99	TH1F* fDeltaTheta; //! histogram of delta_theta values for tracklets (only for SPD analysis)
	100	TH2F* fFiredChips; //! fired chips l1+l2 vs. number of tracklets (only for SPD analysis)
	101	TH2F* fTrackletsVsClusters; //! number of tracklets vs. clusters in all ITS detectors (only for SPD analysis)
	102	TH2F* fTrackletsVsUnassigned; //! number of tracklets vs. number of unassigned clusters in L1 (only for SPD analysis)
	103	TH1F* fStats; //! further statistics : bin 1 = vertexer 3d, bin 2 = vertexer z, etc (see CreateOutputObjects)
	104	TH2F* fStats2; //! V0 vs SPD statistics
	105	Float_t fPtMin; // pt min, to be used in kOneTrack case
	106	TH1D* fEta; //! eta distribution from ESD
	107	TH1D* fEtaMC; //! eta distribution from MC
	108	TH1D* fHistEvents; //! histo for n. of selected ESD events
	109	TH1D* fHistEventsMC; //! histo for n. of selected MC events
	110	TH1D* fTrigEffNum; //!
	111	TH1D* fTrigEffDen; //!
	112	TH1D* fVtxEffNum; //!
	113	TH1D* fVtxEffDen; //!
	114	TH1D* fVtxTrigEffNum; //!
	115	TH1D* fVtxTrigEffDen; //!
	116	private:
	117	AlidNdEtaTask(const AlidNdEtaTask&);
	118	AlidNdEtaTask& operator=(const AlidNdEtaTask&);
	119
	120	ClassDef(AlidNdEtaTask, 2);
	121	};
	122
	123	#endif