[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnSelectorRL.h

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

//-------------------------------------------------------------------------
//  Class AliRsnSelectorRL
// ------------------------
// Reader for conversion of ESD output into the internal format
// used for resonance study.
// ---
// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
// ---
// adapted for TSelector compliance
// by    : R. Vernet                 (email: renaud.vernet@cern.ch)
//-------------------------------------------------------------------------

#ifndef ALIRSNSELECTORRL_H
#define ALIRSNSELECTORRL_H

#include "AliPID.h"
#include "AliSelectorRL.h"

class TH3D;
class TH1D;
class TOrdCollection;
class TTree;
class TBranch;
class AliRunLoader;

class AliRsnSelectorRL : public AliSelectorRL
{
public:

	enum EPIDMethod {
    	kNoPID = 0,                  // no PID performed
		kPerfectPID = 1,             // use Kinematics to simulate a 100% PID efficiency
		kESDPID = 2,                 // use experimental ESD weights
		kPerfectPIDwithRecSign = 3   // get particle type from Kine and charge sign from reconstruction
	};
	
	                      AliRsnSelectorRL(TTree *tree = 0);
			      AliRsnSelectorRL(const AliRsnSelectorRL& obj);
	virtual              ~AliRsnSelectorRL();
	AliRsnSelectorRL&     operator=(const AliRsnSelectorRL& obj);
	
	// TSelector-inherited member functions
	virtual Int_t   Version() const {return 1;}
	virtual void    Begin(TTree *tree) const;
	virtual void    SlaveBegin(TTree *tree);
	virtual void    Init(TTree *tree);
	virtual Bool_t  Process(Long64_t entry);
	virtual void    SetOption(const char *option) {fOption = option;}
	virtual void    SetObject(TObject *obj) {fObject = obj;}
	virtual void    SetInputList(TList *input) {fInput = input;}
	virtual TList  *GetOutputList() const {return fOutput;}
	virtual void    SlaveTerminate() ;
	virtual void    Terminate();
	
	// Parameter/flag setting
	void            SetDebugFlag(Bool_t flag)     {fDebugFlag=flag;}
	void            SetOutputFile(char* file)     {fOutputPath=new TString(file);}
	void            SetStoreKineInfo(Bool_t flag) {fStoreKineInfo=flag;}
	void            SetCheckITSRefit(Bool_t b)    {fCheckITSRefit=b;}
	void            SetRejectFakes(Bool_t b)      {fRejectFakes=b;}
	void            SetCopyMomentum(Bool_t b)     {fCopyMomentum=b;}
	
	// Other
	void            Clear(const Option_t *option = "");
	Double_t*       GetPIDprobabilities(AliRsnDaughter track) const;
	void            Identify(AliRsnDaughter &track);
	void            SetMaxRadius(Double_t value) {fMaxRadius=value;}
	void            SetPIDMethod(AliRsnSelectorRL::EPIDMethod pm) {fPIDMethod=pm;}
	void            SetPriorProbabilities(Double_t *prior);
	void            SetPriorProbability(AliPID::EParticleType type, Double_t p);
	void            SetProbabilityThreshold(Double_t p) {fProbThreshold=p;}
	void            SetPtLimit4PID(Double_t value) {fPtLimit4PID=value;}
	
 protected:
 
 	// Parameters/flags
	TString*      fOutputPath;       //! path where output tree will be stored
	Bool_t        fDebugFlag;        //  flag for debug
	Bool_t        fStoreKineInfo;    //  store MC information
	Bool_t        fCheckITSRefit;    //  accept tracks only if flag AliESDtrack::kITSrefit
	Bool_t        fRejectFakes;      //  reject fake tracks
	Bool_t        fCopyMomentum;     //  store MC momentum instead of reconstructed momentum
	
	// Workaround for AliSelectorRL:
	Bool_t        fIsRunLoaderOpen;  //  flag to check if run loader is open
	
	// IO tree
	TTree*        fRsnEventTree;     //  output tree which should contain AliRsnEvents
	AliRsnEvent*  fRsnEvent;         //  pointer on AliRsnEvent to store
	TBranch*      fRsnEventBranch;   //  tree branch to store AliRsnEvents in
	
	// PID
	EPIDMethod    fPIDMethod;                //  PID method
	Double_t      fPrior[AliPID::kSPECIES];  //  prior probabilities (in case of REAL pid)
	Double_t      fPtLimit4PID;              //  maximum transverse momentum to accept realistic PID
	Double_t      fProbThreshold;            //  minimum required probability to accept realistic PID
	Double_t      fMaxRadius;                //  maximum allowed distance from primary vertex
	
	// Functions
	AliPID::EParticleType FindType(Int_t pdg);
	
	// Rsn event reader implementation
	ClassDef(AliRsnSelectorRL,1)
};

#endif
Commit	Line	Data
62c607bd	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* See cxx source for full Copyright notice *
	4	**************************************************************************/
	5
	6	//-------------------------------------------------------------------------
	7	// Class AliRsnSelectorRL
	8	// ------------------------
	9	// Reader for conversion of ESD output into the internal format
	10	// used for resonance study.
	11	// ---
	12	// author: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
	13	// ---
	14	// adapted for TSelector compliance
	15	// by : R. Vernet (email: renaud.vernet@cern.ch)
	16	//-------------------------------------------------------------------------
	17
	18	#ifndef ALIRSNSELECTORRL_H
	19	#define ALIRSNSELECTORRL_H
	20
	21	#include "AliPID.h"
	22	#include "AliSelectorRL.h"
	23
	24	class TH3D;
	25	class TH1D;
	26	class TOrdCollection;
	27	class TTree;
	28	class TBranch;
	29	class AliRunLoader;
	30
	31	class AliRsnSelectorRL : public AliSelectorRL
	32	{
	33	public:
	34
	35	enum EPIDMethod {
	36	kNoPID = 0, // no PID performed
	37	kPerfectPID = 1, // use Kinematics to simulate a 100% PID efficiency
	38	kESDPID = 2, // use experimental ESD weights
	39	kPerfectPIDwithRecSign = 3 // get particle type from Kine and charge sign from reconstruction
	40	};
	41
	42	AliRsnSelectorRL(TTree *tree = 0);
307afb16	43	AliRsnSelectorRL(const AliRsnSelectorRL& obj);
62c607bd	44	virtual ~AliRsnSelectorRL();
307afb16	45	AliRsnSelectorRL& operator=(const AliRsnSelectorRL& obj);
62c607bd	46
	47	// TSelector-inherited member functions
	48	virtual Int_t Version() const {return 1;}
307afb16	49	virtual void Begin(TTree *tree) const;
62c607bd	50	virtual void SlaveBegin(TTree *tree);
62c607bd	51	virtual void Init(TTree *tree);
62c607bd	52	virtual Bool_t Process(Long64_t entry);
	53	virtual void SetOption(const char *option) {fOption = option;}
	54	virtual void SetObject(TObject *obj) {fObject = obj;}
	55	virtual void SetInputList(TList *input) {fInput = input;}
	56	virtual TList *GetOutputList() const {return fOutput;}
307afb16	57	virtual void SlaveTerminate() ;
62c607bd	58	virtual void Terminate();
	59
	60	// Parameter/flag setting
	61	void SetDebugFlag(Bool_t flag) {fDebugFlag=flag;}
	62	void SetOutputFile(char* file) {fOutputPath=new TString(file);}
	63	void SetStoreKineInfo(Bool_t flag) {fStoreKineInfo=flag;}
	64	void SetCheckITSRefit(Bool_t b) {fCheckITSRefit=b;}
	65	void SetRejectFakes(Bool_t b) {fRejectFakes=b;}
	66	void SetCopyMomentum(Bool_t b) {fCopyMomentum=b;}
	67
	68	// Other
	69	void Clear(const Option_t *option = "");
307afb16	70	Double_t* GetPIDprobabilities(AliRsnDaughter track) const;
62c607bd	71	void Identify(AliRsnDaughter &track);
	72	void SetMaxRadius(Double_t value) {fMaxRadius=value;}
	73	void SetPIDMethod(AliRsnSelectorRL::EPIDMethod pm) {fPIDMethod=pm;}
	74	void SetPriorProbabilities(Double_t *prior);
	75	void SetPriorProbability(AliPID::EParticleType type, Double_t p);
	76	void SetProbabilityThreshold(Double_t p) {fProbThreshold=p;}
	77	void SetPtLimit4PID(Double_t value) {fPtLimit4PID=value;}
	78
	79	protected:
	80
	81	// Parameters/flags
307afb16	82	TString* fOutputPath; //! path where output tree will be stored
	83	Bool_t fDebugFlag; // flag for debug
	84	Bool_t fStoreKineInfo; // store MC information
	85	Bool_t fCheckITSRefit; // accept tracks only if flag AliESDtrack::kITSrefit
	86	Bool_t fRejectFakes; // reject fake tracks
	87	Bool_t fCopyMomentum; // store MC momentum instead of reconstructed momentum
62c607bd	88
62c607bd	89	// Workaround for AliSelectorRL:
307afb16	90	Bool_t fIsRunLoaderOpen; // flag to check if run loader is open
62c607bd	91
62c607bd	92	// IO tree
307afb16	93	TTree* fRsnEventTree; // output tree which should contain AliRsnEvents
	94	AliRsnEvent* fRsnEvent; // pointer on AliRsnEvent to store
	95	TBranch* fRsnEventBranch; // tree branch to store AliRsnEvents in
62c607bd	96
	97	// PID
	98	EPIDMethod fPIDMethod; // PID method
	99	Double_t fPrior[AliPID::kSPECIES]; // prior probabilities (in case of REAL pid)
	100	Double_t fPtLimit4PID; // maximum transverse momentum to accept realistic PID
	101	Double_t fProbThreshold; // minimum required probability to accept realistic PID
	102	Double_t fMaxRadius; // maximum allowed distance from primary vertex
	103
	104	// Functions
	105	AliPID::EParticleType FindType(Int_t pdg);
	106
	107	// Rsn event reader implementation
	108	ClassDef(AliRsnSelectorRL,1)
	109	};
	110
	111	#endif
	112