[u/mrichter/AliRoot.git] / ANALYSIS / AliBaseEventCut.h

#ifndef ALIBASEEVENTCUT_H
#define ALIBASEEVENTCUT_H
//________________________________
///////////////////////////////////////////////////////////
//
// class AliBaseEventCut
//
// Base class for cauts that checks only one event property
//
// Piotr.Skowronski@cern.ch
//
///////////////////////////////////////////////////////////

#include "TObject.h"

class AliAOD;

enum AliEventCutProperty
 {
   kPrimVertexXCut,
   kPrimVertexYCut,
   kPrimVertexZCut,
   kNChargedCut
 };

class AliBaseEventCut: public TObject
{
  public: 
    AliBaseEventCut();
    AliBaseEventCut(Double_t min,Double_t max);
    virtual ~AliBaseEventCut(){}
    
    virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
  protected:
    virtual Double_t GetValue(AliAOD* aod) const = 0;
    
    Double_t fMin;//Minimum value
    Double_t fMax;//Maximum value
  private:
    ClassDef(AliBaseEventCut,1)
};

/************************************************************/

class AliPrimVertexXCut: public AliBaseEventCut
{
 public: 
   AliPrimVertexXCut(){}
   AliPrimVertexXCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
   virtual ~AliPrimVertexXCut(){}
 protected:
   Double_t GetValue(AliAOD* aod) const;
   
 private:
   ClassDef(AliPrimVertexXCut,1)
};
/************************************************************/

class AliPrimVertexYCut: public AliBaseEventCut
{
 public: 
   AliPrimVertexYCut(){}
   AliPrimVertexYCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
   virtual ~AliPrimVertexYCut(){}
   
 protected:
   Double_t GetValue(AliAOD* aod) const;
   
 private:
   ClassDef(AliPrimVertexYCut,1)
};
/************************************************************/

class AliPrimVertexZCut: public AliBaseEventCut
{
 public: 
   AliPrimVertexZCut(){}
   AliPrimVertexZCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
   virtual ~AliPrimVertexZCut(){}
 protected:
   Double_t GetValue(AliAOD* aod) const;
   
 private:
   ClassDef(AliPrimVertexZCut,1)
};


/************************************************************/

class AliNChargedCut: public AliBaseEventCut
{
 public: 
   AliNChargedCut(){}
   AliNChargedCut(Double_t min, Double_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
       AliBaseEventCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
   virtual ~AliNChargedCut(){}
 protected:
   Double_t GetValue(AliAOD* aod) const;
   Double_t fEtaMin;//Defines max of eta range where mult is caclulated
   Double_t fEtaMax;//Defines min of eta range where mult is caclulated
   
 private:
   ClassDef(AliNChargedCut,1)
};


#endif
Commit	Line	Data
b26900d0	1	#ifndef ALIBASEEVENTCUT_H
	2	#define ALIBASEEVENTCUT_H
	3	//________________________________
	4	///////////////////////////////////////////////////////////
	5	//
	6	// class AliBaseEventCut
	7	//
	8	// Base class for cauts that checks only one event property
	9	//
	10	// Piotr.Skowronski@cern.ch
	11	//
	12	///////////////////////////////////////////////////////////
	13
	14	#include "TObject.h"
	15
a5556ea5	16	class AliAOD;
b26900d0	17
0d8a4589	18	enum AliEventCutProperty
	19	{
	20	kPrimVertexXCut,
	21	kPrimVertexYCut,
	22	kPrimVertexZCut,
	23	kNChargedCut
	24	};
	25
b26900d0	26	class AliBaseEventCut: public TObject
	27	{
	28	public:
	29	AliBaseEventCut();
0d8a4589	30	AliBaseEventCut(Double_t min,Double_t max);
b26900d0	31	virtual ~AliBaseEventCut(){}
b26900d0	32
a5556ea5	33	virtual Bool_t Pass(AliAOD* aod) const;//returns kTRUE if rejected
b26900d0	34	protected:
a5556ea5	35	virtual Double_t GetValue(AliAOD* aod) const = 0;
b26900d0	36
	37	Double_t fMin;//Minimum value
	38	Double_t fMax;//Maximum value
	39	private:
	40	ClassDef(AliBaseEventCut,1)
	41	};
	42
0d8a4589	43	/************************************************************/
	44
	45	class AliPrimVertexXCut: public AliBaseEventCut
	46	{
	47	public:
	48	AliPrimVertexXCut(){}
	49	AliPrimVertexXCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
	50	virtual ~AliPrimVertexXCut(){}
	51	protected:
	52	Double_t GetValue(AliAOD* aod) const;
	53
	54	private:
	55	ClassDef(AliPrimVertexXCut,1)
	56	};
	57	/************************************************************/
	58
	59	class AliPrimVertexYCut: public AliBaseEventCut
	60	{
	61	public:
	62	AliPrimVertexYCut(){}
	63	AliPrimVertexYCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
	64	virtual ~AliPrimVertexYCut(){}
	65
	66	protected:
	67	Double_t GetValue(AliAOD* aod) const;
	68
	69	private:
	70	ClassDef(AliPrimVertexYCut,1)
	71	};
	72	/************************************************************/
	73
	74	class AliPrimVertexZCut: public AliBaseEventCut
	75	{
	76	public:
	77	AliPrimVertexZCut(){}
	78	AliPrimVertexZCut(Double_t min,Double_t max):AliBaseEventCut(min,max){}
	79	virtual ~AliPrimVertexZCut(){}
	80	protected:
	81	Double_t GetValue(AliAOD* aod) const;
	82
	83	private:
	84	ClassDef(AliPrimVertexZCut,1)
	85	};
	86
	87
	88	/************************************************************/
	89
	90	class AliNChargedCut: public AliBaseEventCut
	91	{
	92	public:
	93	AliNChargedCut(){}
	94	AliNChargedCut(Double_t min, Double_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
	95	AliBaseEventCut(min,max),fEtaMin(etamin),fEtaMax(etamax){}
	96	virtual ~AliNChargedCut(){}
	97	protected:
	98	Double_t GetValue(AliAOD* aod) const;
	99	Double_t fEtaMin;//Defines max of eta range where mult is caclulated
	100	Double_t fEtaMax;//Defines min of eta range where mult is caclulated
	101
	102	private:
	103	ClassDef(AliNChargedCut,1)
	104	};
	105
	106
b26900d0	107	#endif