[u/mrichter/AliRoot.git] / PWGCF / Correlations / Base / AliAnalysisTaskCFTree.h

#ifndef AliAnalysisTaskCFTree_h
#define AliAnalysisTaskCFTree_h

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

// Analysis task to produce trees of lightweight events
// evgeny.kryshen@cern.ch

#include "AliAnalysisTask.h"
class AliInputEventHandler;
class TList;
class TH1I;
class TTree;
class TClonesArray;
class AliAnalysisFilter;
class AliPIDResponse;
class AliVParticle;
class AliCFParticle;

class AliAnalysisTaskCFTree : public AliAnalysisTask {
 public:
  AliAnalysisTaskCFTree(const char* name="AliAnalysisTaskCFTree");
  virtual ~AliAnalysisTaskCFTree(){};
  virtual void ConnectInputData(Option_t *);
  virtual void CreateOutputObjects();
  virtual void Exec(Option_t *option);

  void SetTrackFilter(AliAnalysisFilter* filter) { fTrackFilter = filter; }
  void SetHybridConstrainedMask(UInt_t mask)  { fHybridConstrainedMask = mask; }
  void SetTPConlyConstrainedMask(UInt_t mask) { fTPConlyConstrainedMask = mask; }
  void SetDebug(Int_t val)              { fDebug = val; }
  void SetMode(Int_t val)               { fMode = val; }
  void SetAOD(Bool_t val)               { fIsAOD = val; }
  // Event cut setters
  void SetEventSelectionBit(UInt_t val) { fSelectBit = val; }
  void SetZVertex(Float_t val)          { fZVertexCut = val; }
  void SetTracksInVertex(Int_t val)     { fnTracksVertex = val; }
  void SetCentralityMethod(char* val)   { fCentralityMethod = val; }
  // Track cut setters
  void SetTrackFilterBit(UInt_t val)    { fTrackFilterBit = val; }
  void SetTrackEtaCut(Float_t val)      { fTrackEtaCut = val; }
  void SetPtMin(Float_t val)            { fPtMin = val; } 
  void SetSharedClusterCut(Float_t val) { fSharedClusterCut = val;  }
  void SetCrossedRowsCut(Int_t val)     { fCrossedRowsCut = val; }
  void SetFoundFractionCut(Float_t val) { fFoundFractionCut = val;  }
  void SetDphiCut(Float_t val)          { fDphiCut = val; }
  // Switchers for additional data to be stored
  void SetStoreTracks(Bool_t val=kTRUE)    { fStoreTracks    = val; }
  void SetStoreTracklets(Bool_t val=kTRUE) { fStoreTracklets = val; }
  void SetStoreMuons(Bool_t val=kTRUE)     { fStoreMuons     = val; }

 protected:
  AliAnalysisTaskCFTree(const  AliAnalysisTaskCFTree &task);
  AliAnalysisTaskCFTree& operator=(const  AliAnalysisTaskCFTree &task);

  UInt_t GetFilterMap(AliVParticle* part);
  AliCFParticle* AddTrack(AliVParticle* track, UInt_t mask, UInt_t flag=0);

  Int_t fDebug;               // debug level
  Int_t fMode;                // Analysis mode: 0 - data, 1 - mc
  Bool_t fIsAOD;              // kTRUE - AOD
  AliInputEventHandler* fInputHandler; // AOD or ESD input handler 
  AliInputEventHandler* fMcHandler;    // MC input handler (ESD)
  AliAnalysisFilter* fTrackFilter;     // track filter used in ESD analysis
  UInt_t fHybridConstrainedMask;       // Filter mask for hybrid constrained tracks (ESD analysis)
  UInt_t fTPConlyConstrainedMask;      // Filter mask for TPConly constrained tracks (ESD analysis)
  AliPIDResponse* fPIDResponse;        //!
  TList* fListOfHistos;       //! list of output histograms
  TH1I*  fEventStatistics;    //! cut-by-cut counter of events
  TTree* fTree;               //! output tree
  // Tree variables
  TClonesArray* fParticles;   //! tree var: selected AliCFParticles
  TClonesArray* fTracklets;   //! tree var: selected tracklets (stored if fStoreTracklets=kTRUE)
  TClonesArray* fMuons;       //! tree var: selected muons (stored if fStoreMuons=kTRUE)
  Float_t fField;             //  tree var: magnetic field value
  Float_t fCentrality;        //  tree var: centrality
  Float_t fZvtx;              //  tree var: z-vertex
  Int_t fRunNumber;           //  tree var: run number
  UInt_t fPeriod;             //  tree var: period
  UInt_t fOrbit;              //  tree var: orbit
  UShort_t fBc;               //  tree var: bunch crossing
  UInt_t fSelectMask;         //  tree var: physics selection mask
  // Event cuts
  UInt_t fSelectBit;          // event selection bit
  Float_t fZVertexCut;        // Z-vertex cut
  Int_t fnTracksVertex;       // min number of vertex contributors
  TString  fCentralityMethod; // method to determine centrality
  // Track cuts
  UInt_t fTrackFilterBit;     // track filter bits to be stored
  Float_t fTrackEtaCut;       // maximum abs(eta) cut
  Float_t fPtMin;             // minimum pt cut
  Float_t fSharedClusterCut;  // cut on shared clusters
  Int_t   fCrossedRowsCut;    // cut on crossed rows
  Float_t fFoundFractionCut;  // cut on crossed rows/findable clusters
  Float_t fDphiCut;           // cut on tracklet dphi
  //
  Bool_t fStoreTracks;        // if kTRUE - Barrel tracks will be stored as AliCFParticles
  Bool_t fStoreTracklets;     // if kTRUE - SPD tracklets will be stored as AliCFParticles
  Bool_t fStoreMuons;         // if kTRUE - muon tracks will be stored as AliCFParticles
  ClassDef(AliAnalysisTaskCFTree,3);
};
#endif
Commit	Line	Data
5fe7e785	1	#ifndef AliAnalysisTaskCFTree_h
	2	#define AliAnalysisTaskCFTree_h
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	// Analysis task to produce trees of lightweight events
	8	// evgeny.kryshen@cern.ch
	9
	10	#include "AliAnalysisTask.h"
	11	class AliInputEventHandler;
	12	class TList;
	13	class TH1I;
	14	class TTree;
	15	class TClonesArray;
	16	class AliAnalysisFilter;
	17	class AliPIDResponse;
	18	class AliVParticle;
	19	class AliCFParticle;
	20
	21	class AliAnalysisTaskCFTree : public AliAnalysisTask {
	22	public:
	23	AliAnalysisTaskCFTree(const char* name="AliAnalysisTaskCFTree");
	24	virtual ~AliAnalysisTaskCFTree(){};
	25	virtual void ConnectInputData(Option_t *);
	26	virtual void CreateOutputObjects();
	27	virtual void Exec(Option_t *option);
	28
	29	void SetTrackFilter(AliAnalysisFilter* filter) { fTrackFilter = filter; }
	30	void SetHybridConstrainedMask(UInt_t mask) { fHybridConstrainedMask = mask; }
	31	void SetTPConlyConstrainedMask(UInt_t mask) { fTPConlyConstrainedMask = mask; }
	32	void SetDebug(Int_t val) { fDebug = val; }
	33	void SetMode(Int_t val) { fMode = val; }
4c66fa46	34	void SetAOD(Bool_t val) { fIsAOD = val; }
5fe7e785	35	// Event cut setters
	36	void SetEventSelectionBit(UInt_t val) { fSelectBit = val; }
	37	void SetZVertex(Float_t val) { fZVertexCut = val; }
	38	void SetTracksInVertex(Int_t val) { fnTracksVertex = val; }
	39	void SetCentralityMethod(char* val) { fCentralityMethod = val; }
	40	// Track cut setters
	41	void SetTrackFilterBit(UInt_t val) { fTrackFilterBit = val; }
	42	void SetTrackEtaCut(Float_t val) { fTrackEtaCut = val; }
	43	void SetPtMin(Float_t val) { fPtMin = val; }
	44	void SetSharedClusterCut(Float_t val) { fSharedClusterCut = val; }
	45	void SetCrossedRowsCut(Int_t val) { fCrossedRowsCut = val; }
	46	void SetFoundFractionCut(Float_t val) { fFoundFractionCut = val; }
c0ff46c8	47	void SetDphiCut(Float_t val) { fDphiCut = val; }
4c66fa46	48	// Switchers for additional data to be stored
8e77b3fd	49	void SetStoreTracks(Bool_t val=kTRUE) { fStoreTracks = val; }
4c66fa46	50	void SetStoreTracklets(Bool_t val=kTRUE) { fStoreTracklets = val; }
4c66fa46	51	void SetStoreMuons(Bool_t val=kTRUE) { fStoreMuons = val; }
5fe7e785	52
	53	protected:
	54	AliAnalysisTaskCFTree(const AliAnalysisTaskCFTree &task);
	55	AliAnalysisTaskCFTree& operator=(const AliAnalysisTaskCFTree &task);
	56
	57	UInt_t GetFilterMap(AliVParticle* part);
	58	AliCFParticle* AddTrack(AliVParticle* track, UInt_t mask, UInt_t flag=0);
	59
	60	Int_t fDebug; // debug level
	61	Int_t fMode; // Analysis mode: 0 - data, 1 - mc
4c66fa46	62	Bool_t fIsAOD; // kTRUE - AOD
5fe7e785	63	AliInputEventHandler* fInputHandler; // AOD or ESD input handler
	64	AliInputEventHandler* fMcHandler; // MC input handler (ESD)
	65	AliAnalysisFilter* fTrackFilter; // track filter used in ESD analysis
	66	UInt_t fHybridConstrainedMask; // Filter mask for hybrid constrained tracks (ESD analysis)
	67	UInt_t fTPConlyConstrainedMask; // Filter mask for TPConly constrained tracks (ESD analysis)
	68	AliPIDResponse* fPIDResponse; //!
	69	TList* fListOfHistos; //! list of output histograms
	70	TH1I* fEventStatistics; //! cut-by-cut counter of events
	71	TTree* fTree; //! output tree
	72	// Tree variables
	73	TClonesArray* fParticles; //! tree var: selected AliCFParticles
4c66fa46	74	TClonesArray* fTracklets; //! tree var: selected tracklets (stored if fStoreTracklets=kTRUE)
4c66fa46	75	TClonesArray* fMuons; //! tree var: selected muons (stored if fStoreMuons=kTRUE)
5fe7e785	76	Float_t fField; // tree var: magnetic field value
	77	Float_t fCentrality; // tree var: centrality
	78	Float_t fZvtx; // tree var: z-vertex
	79	Int_t fRunNumber; // tree var: run number
	80	UInt_t fPeriod; // tree var: period
	81	UInt_t fOrbit; // tree var: orbit
	82	UShort_t fBc; // tree var: bunch crossing
	83	UInt_t fSelectMask; // tree var: physics selection mask
	84	// Event cuts
	85	UInt_t fSelectBit; // event selection bit
	86	Float_t fZVertexCut; // Z-vertex cut
	87	Int_t fnTracksVertex; // min number of vertex contributors
	88	TString fCentralityMethod; // method to determine centrality
	89	// Track cuts
	90	UInt_t fTrackFilterBit; // track filter bits to be stored
	91	Float_t fTrackEtaCut; // maximum abs(eta) cut
	92	Float_t fPtMin; // minimum pt cut
	93	Float_t fSharedClusterCut; // cut on shared clusters
	94	Int_t fCrossedRowsCut; // cut on crossed rows
	95	Float_t fFoundFractionCut; // cut on crossed rows/findable clusters
c0ff46c8	96	Float_t fDphiCut; // cut on tracklet dphi
4c66fa46	97	//
8e77b3fd	98	Bool_t fStoreTracks; // if kTRUE - Barrel tracks will be stored as AliCFParticles
4c66fa46	99	Bool_t fStoreTracklets; // if kTRUE - SPD tracklets will be stored as AliCFParticles
4c66fa46	100	Bool_t fStoreMuons; // if kTRUE - muon tracks will be stored as AliCFParticles
c0ff46c8	101	ClassDef(AliAnalysisTaskCFTree,3);
5fe7e785	102	};
	103	#endif
	104