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

#ifndef ALIAODPAIRBASECUT_H
#define ALIAODPAIRBASECUT_H

#include <TNamed.h> 
#include "AliAODPair.h"


class AliAODPairBaseCut: public TObject
{
  //This class defines the range of some property - pure virtual
  //Property is coded by AliAODCutTypes type
   
 public:

  enum EAODPairCutProperty
    {
      kHbtPairCutPropQInv, //Q invariant
      kHbtPairCutPropKt,
      kHbtPairCutPropKStar,
      kHbtPairCutPropQSideLCMS,
      kHbtPairCutPropQOutLCMS,
      kHbtPairCutPropQLongLCMS,
      kHbtPairCutPropDeltaPhi,
      kHbtPairCutPropDeltaTheta,
      kHbtPairCutPropDeltaE,
      kHbtPairCutPropDeltaP,//scalar difference
      kHbtPairCutPropDeltaPvector,//legth of the momenta difference vector
      kHbtPairCutPropDeltaPt,
      kHbtPairCutPropAvSepar,
      kHbtPairCutPropSepar,
      kHbtPairCutPropClOverlap,
      kHbtPairCutPropPixelSepar,
      kHbtPairCutPropNone
    };

  AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, EAODPairCutProperty prop= kHbtPairCutPropNone):
    fMin(min),fMax(max),fProperty(prop){}
  
  virtual   ~AliAODPairBaseCut(){}
     
  virtual Bool_t    Rejected(AliAODPair* pair) const;
  
  void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
  
  void      SetMinimum(Double_t min){fMin = min;}
  void      SetMaximum(Double_t max){fMax = max;}
  
  Double_t  GetMinimum() const {return fMin;}
  Double_t  GetMaximum() const {return fMax;}
  
  EAODPairCutProperty GetProperty() const {return fProperty;}
  
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const = 0;
  
  Double_t fMin; // Lower boundary of the range
  Double_t fMax; // Upper boundary of the range
  
  EAODPairCutProperty fProperty; // The property itself
  
  ClassDef(AliAODPairBaseCut,1)
 
 };
/******************************************************************/

inline Bool_t AliAODPairBaseCut::Rejected(AliAODPair* pair) const
{
  //checks if pair proprty is in range
  //null pointer check is made by AliAODPairCut, so here is unnecesary
  
  Double_t value = GetValue(pair);
  if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
  else return kTRUE; //rejected
}
/******************************************************************/
/******************************************************************/
/******************************************************************/

class AliAODQInvCut: public AliAODPairBaseCut
{
 public:
  AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropQInv){}
  virtual ~AliAODQInvCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetQInv();}
  
  ClassDef(AliAODQInvCut,1)
 };
/******************************************************************/

class AliAODKtCut: public AliAODPairBaseCut {
 public:
  AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKt){}
  virtual ~AliAODKtCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKt();}

  ClassDef(AliAODKtCut,1)
 };
/******************************************************************/

class AliAODKStarCut: public AliAODPairBaseCut
{
 public:
  AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStar){}
  virtual ~AliAODKStarCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStar();}

  ClassDef(AliAODKStarCut,1)
};
/******************************************************************/

class AliAODQSideLCMSCut: public AliAODPairBaseCut
{
 public:
  AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
  virtual ~AliAODQSideLCMSCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetQSideLCMS();}

  ClassDef(AliAODQSideLCMSCut,1)
};
/******************************************************************/


class AliAODQOutLCMSCut: public AliAODPairBaseCut
{
 public:
  AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
  virtual ~AliAODQOutLCMSCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetQOutLCMS();}
  
  ClassDef(AliAODQOutLCMSCut,1)
};
/******************************************************************/

class AliAODQLongLCMSCut: public AliAODPairBaseCut
{
 public:
  AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
  virtual ~AliAODQLongLCMSCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetQLongLCMS();}

  ClassDef(AliAODQLongLCMSCut,1)
};
/******************************************************************/

class AliAODDeltaECut: public AliAODPairBaseCut
{
 public:
  AliAODDeltaECut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaE){}
  virtual ~AliAODDeltaECut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetDeltaE();}

  ClassDef(AliAODDeltaECut,1)
};
/******************************************************************/

class AliAODDeltaPCut: public AliAODPairBaseCut
{
 public:
  AliAODDeltaPCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaP){}
  virtual ~AliAODDeltaPCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetDeltaP();}

  ClassDef(AliAODDeltaPCut,1)
};
/******************************************************************/

class AliAODDeltaPvectorCut: public AliAODPairBaseCut
{
 public:
  AliAODDeltaPvectorCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPvector){}
  virtual ~AliAODDeltaPvectorCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return pair->GetDeltaPvector();}

  ClassDef(AliAODDeltaPvectorCut,1)
};
/******************************************************************/

class AliAODDeltaPhiCut: public AliAODPairBaseCut
{
 public:
  AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
  virtual ~AliAODDeltaPhiCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return TMath::Abs(pair->GetDeltaPhi());}

  ClassDef(AliAODDeltaPhiCut,1)
};
/******************************************************************/

class AliAODDeltaThetaCut: public AliAODPairBaseCut
{
 public:
  AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
  virtual ~AliAODDeltaThetaCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const 
    {return TMath::Abs(pair->GetDeltaTheta());}

  ClassDef(AliAODDeltaThetaCut,1)
};
/******************************************************************/

class AliAODCluterOverlapCut: public AliAODPairBaseCut
{
 public:
  AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
    AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
  virtual ~AliAODCluterOverlapCut(){}

 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const;
  ClassDef(AliAODCluterOverlapCut,1)
};
/******************************************************************/
  
class AliAODAvSeparationCut: public AliAODPairBaseCut
{
 public:
  AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
    AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
  virtual ~AliAODAvSeparationCut(){}
  
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const;
  ClassDef(AliAODAvSeparationCut,1)
};
/******************************************************************/
  
class AliAODSeparationCut: public AliAODPairBaseCut
{
 public:
  AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
    AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
  virtual ~AliAODSeparationCut(){}
  
 protected:
  Int_t fPoint;//index of the point that distance should be measured
  virtual Double_t  GetValue(AliAODPair* pair) const;
  ClassDef(AliAODSeparationCut,1)
};
/******************************************************************/
  
class AliAODITSSeparationCut: public AliAODPairBaseCut
{
//Anti merging cut for the first layer of pixels
 public:
  AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
    AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
  virtual ~AliAODITSSeparationCut(){}
  Bool_t   Rejected(AliAODPair* pair) const;
  Int_t    GetLayer() const {return fLayer;}
 protected:
  Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}//not used
  ClassDef(AliAODITSSeparationCut,1)
};
/******************************************************************/

class AliAODOutSideSameSignCut: public AliAODPairBaseCut
{
 public:
  AliAODOutSideSameSignCut(){}
  virtual ~AliAODOutSideSameSignCut(){}
  virtual Bool_t Rejected(AliAODPair *p) const;
 protected:
  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
  ClassDef(AliAODOutSideSameSignCut,1)
};
/******************************************************************/

class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
{
 public:
  AliAODOutSideDiffSignCut(){}
  virtual ~AliAODOutSideDiffSignCut(){}
  virtual Bool_t Rejected(AliAODPair *p) const;
 protected:
  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
  ClassDef(AliAODOutSideDiffSignCut,1)
};
/******************************************************************/

class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
 {
   public:
     AliAODLogicalOperPairCut();
     AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
     virtual   ~AliAODLogicalOperPairCut();
   protected:
     Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}

     AliAODPairBaseCut* fFirst;   //second cut
     AliAODPairBaseCut* fSecond;  //first cut
   private:
    class  AliAODDummyBasePairCut: public AliAODPairBaseCut
     {
       Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
       Bool_t    Rejected(AliAODPair* /*pair*/) const;
     };

    ClassDef(AliAODLogicalOperPairCut,1)
 };
/******************************************************************/

class AliAODOrPairCut: public AliAODLogicalOperPairCut
{
   public:
     AliAODOrPairCut(){}
     AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
     virtual   ~AliAODOrPairCut(){}
     Bool_t    Rejected(AliAODPair *p) const;
     ClassDef(AliAODOrPairCut,1)
};
/******************************************************************/

class AliAODAndPairCut: public AliAODLogicalOperPairCut
{
   public:
     AliAODAndPairCut(){}
     AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
     virtual   ~AliAODAndPairCut(){}
     Bool_t    Rejected(AliAODPair *p) const;
     ClassDef(AliAODAndPairCut,1)
};

#endif
Commit	Line	Data
073745bc	1	#ifndef ALIAODPAIRBASECUT_H
	2	#define ALIAODPAIRBASECUT_H
	3
	4	#include <TNamed.h>
	5	#include "AliAODPair.h"
	6
	7
	8	class AliAODPairBaseCut: public TObject
	9	{
	10	//This class defines the range of some property - pure virtual
	11	//Property is coded by AliAODCutTypes type
	12
	13	public:
	14
	15	enum EAODPairCutProperty
	16	{
	17	kHbtPairCutPropQInv, //Q invariant
	18	kHbtPairCutPropKt,
	19	kHbtPairCutPropKStar,
	20	kHbtPairCutPropQSideLCMS,
	21	kHbtPairCutPropQOutLCMS,
	22	kHbtPairCutPropQLongLCMS,
	23	kHbtPairCutPropDeltaPhi,
	24	kHbtPairCutPropDeltaTheta,
b327f095	25	kHbtPairCutPropDeltaE,
	26	kHbtPairCutPropDeltaP,//scalar difference
	27	kHbtPairCutPropDeltaPvector,//legth of the momenta difference vector
073745bc	28	kHbtPairCutPropDeltaPt,
	29	kHbtPairCutPropAvSepar,
	30	kHbtPairCutPropSepar,
	31	kHbtPairCutPropClOverlap,
	32	kHbtPairCutPropPixelSepar,
	33	kHbtPairCutPropNone
	34	};
	35
	36	AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, EAODPairCutProperty prop= kHbtPairCutPropNone):
	37	fMin(min),fMax(max),fProperty(prop){}
	38
	39	virtual ~AliAODPairBaseCut(){}
	40
	41	virtual Bool_t Rejected(AliAODPair* pair) const;
	42
	43	void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
	44
	45	void SetMinimum(Double_t min){fMin = min;}
	46	void SetMaximum(Double_t max){fMax = max;}
	47
	48	Double_t GetMinimum() const {return fMin;}
	49	Double_t GetMaximum() const {return fMax;}
	50
	51	EAODPairCutProperty GetProperty() const {return fProperty;}
	52
	53	protected:
	54	virtual Double_t GetValue(AliAODPair* pair) const = 0;
	55
	56	Double_t fMin; // Lower boundary of the range
	57	Double_t fMax; // Upper boundary of the range
	58
	59	EAODPairCutProperty fProperty; // The property itself
	60
	61	ClassDef(AliAODPairBaseCut,1)
	62
	63	};
	64	/******************************************************************/
	65
	66	inline Bool_t AliAODPairBaseCut::Rejected(AliAODPair* pair) const
	67	{
	68	//checks if pair proprty is in range
	69	//null pointer check is made by AliAODPairCut, so here is unnecesary
	70
	71	Double_t value = GetValue(pair);
	72	if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
	73	else return kTRUE; //rejected
	74	}
	75	/******************************************************************/
	76	/******************************************************************/
	77	/******************************************************************/
	78
	79	class AliAODQInvCut: public AliAODPairBaseCut
	80	{
	81	public:
	82	AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropQInv){}
	83	virtual ~AliAODQInvCut(){}
	84	protected:
	85	virtual Double_t GetValue(AliAODPair* pair) const {return pair->GetQInv();}
	86
	87	ClassDef(AliAODQInvCut,1)
	88	};
	89	/******************************************************************/
	90
	91	class AliAODKtCut: public AliAODPairBaseCut {
92	public:
93	AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKt){}
94	virtual ~AliAODKtCut(){}
95	protected:
96	virtual Double_t GetValue(AliAODPair* pair) const {return pair->GetKt();}
97
98	ClassDef(AliAODKtCut,1)
99	};
100	/******************************************************************/
101
102	class AliAODKStarCut: public AliAODPairBaseCut
103	{
104	public:
105	AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStar){}
106	virtual ~AliAODKStarCut(){}
107	protected:
108	virtual Double_t GetValue(AliAODPair* pair) const {return pair->GetKStar();}
109
110	ClassDef(AliAODKStarCut,1)
111	};
112	/******************************************************************/
113
114	class AliAODQSideLCMSCut: public AliAODPairBaseCut
115	{
116	public:
117	AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
118	AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
119	virtual ~AliAODQSideLCMSCut(){}
120	protected:
121	virtual Double_t GetValue(AliAODPair* pair) const
122	{return pair->GetQSideLCMS();}
123
124	ClassDef(AliAODQSideLCMSCut,1)
125	};
126	/******************************************************************/
127
128
129	class AliAODQOutLCMSCut: public AliAODPairBaseCut
130	{
131	public:
132	AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
133	AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
134	virtual ~AliAODQOutLCMSCut(){}
135	protected:
136	virtual Double_t GetValue(AliAODPair* pair) const
137	{return pair->GetQOutLCMS();}
138
139	ClassDef(AliAODQOutLCMSCut,1)
140	};
141	/******************************************************************/
142
143	class AliAODQLongLCMSCut: public AliAODPairBaseCut
144	{
145	public:
146	AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
147	AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
148	virtual ~AliAODQLongLCMSCut(){}
149	protected:
150	virtual Double_t GetValue(AliAODPair* pair) const
151	{return pair->GetQLongLCMS();}
152
153	ClassDef(AliAODQLongLCMSCut,1)
154	};
155	/******************************************************************/
156
b327f095	157	class AliAODDeltaECut: public AliAODPairBaseCut
	158	{
	159	public:
	160	AliAODDeltaECut(Double_t min = 0.0, Double_t max = 0.0):
	161	AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaE){}
	162	virtual ~AliAODDeltaECut(){}
	163	protected:
	164	virtual Double_t GetValue(AliAODPair* pair) const
	165	{return pair->GetDeltaE();}
	166
	167	ClassDef(AliAODDeltaECut,1)
	168	};
	169	/******************************************************************/
	170
	171	class AliAODDeltaPCut: public AliAODPairBaseCut
	172	{
	173	public:
	174	AliAODDeltaPCut(Double_t min = 0.0, Double_t max = 0.0):
	175	AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaP){}
	176	virtual ~AliAODDeltaPCut(){}
	177	protected:
	178	virtual Double_t GetValue(AliAODPair* pair) const
	179	{return pair->GetDeltaP();}
	180
	181	ClassDef(AliAODDeltaPCut,1)
	182	};
	183	/******************************************************************/
	184
	185	class AliAODDeltaPvectorCut: public AliAODPairBaseCut
	186	{
	187	public:
	188	AliAODDeltaPvectorCut(Double_t min = 0.0, Double_t max = 0.0):
	189	AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPvector){}
	190	virtual ~AliAODDeltaPvectorCut(){}
	191	protected:
	192	virtual Double_t GetValue(AliAODPair* pair) const
	193	{return pair->GetDeltaPvector();}
	194
	195	ClassDef(AliAODDeltaPvectorCut,1)
	196	};
	197	/******************************************************************/
	198
073745bc	199	class AliAODDeltaPhiCut: public AliAODPairBaseCut
	200	{
	201	public:
	202	AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
	203	AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
	204	virtual ~AliAODDeltaPhiCut(){}
	205	protected:
	206	virtual Double_t GetValue(AliAODPair* pair) const
	207	{return TMath::Abs(pair->GetDeltaPhi());}
	208
	209	ClassDef(AliAODDeltaPhiCut,1)
	210	};
	211	/******************************************************************/
	212
	213	class AliAODDeltaThetaCut: public AliAODPairBaseCut
	214	{
	215	public:
	216	AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
	217	AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
	218	virtual ~AliAODDeltaThetaCut(){}
	219	protected:
	220	virtual Double_t GetValue(AliAODPair* pair) const
	221	{return TMath::Abs(pair->GetDeltaTheta());}
	222
	223	ClassDef(AliAODDeltaThetaCut,1)
	224	};
	225	/******************************************************************/
	226
	227	class AliAODCluterOverlapCut: public AliAODPairBaseCut
	228	{
	229	public:
	230	AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
	231	AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
	232	virtual ~AliAODCluterOverlapCut(){}
	233
	234	protected:
	235	virtual Double_t GetValue(AliAODPair* pair) const;
	236	ClassDef(AliAODCluterOverlapCut,1)
	237	};
	238	/******************************************************************/
	239
	240	class AliAODAvSeparationCut: public AliAODPairBaseCut
	241	{
	242	public:
	243	AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
	244	AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
	245	virtual ~AliAODAvSeparationCut(){}
	246
	247	protected:
	248	virtual Double_t GetValue(AliAODPair* pair) const;
	249	ClassDef(AliAODAvSeparationCut,1)
	250	};
	251	/******************************************************************/
	252
	253	class AliAODSeparationCut: public AliAODPairBaseCut
	254	{
	255	public:
	256	AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
	257	AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
	258	virtual ~AliAODSeparationCut(){}
	259
	260	protected:
	261	Int_t fPoint;//index of the point that distance should be measured
	262	virtual Double_t GetValue(AliAODPair* pair) const;
263	ClassDef(AliAODSeparationCut,1)
264	};
265	/******************************************************************/
266
267	class AliAODITSSeparationCut: public AliAODPairBaseCut
268	{
269	//Anti merging cut for the first layer of pixels
270	public:
271	AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
272	AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
273	virtual ~AliAODITSSeparationCut(){}
274	Bool_t Rejected(AliAODPair* pair) const;
275	Int_t GetLayer() const {return fLayer;}
276	protected:
277	Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
278	virtual Double_t GetValue(AliAODPair* /pair/) const {return 0.0;}//not used
279	ClassDef(AliAODITSSeparationCut,1)
280	};
281	/******************************************************************/
282
283	class AliAODOutSideSameSignCut: public AliAODPairBaseCut
284	{
285	public:
286	AliAODOutSideSameSignCut(){}
287	virtual ~AliAODOutSideSameSignCut(){}
288	virtual Bool_t Rejected(AliAODPair *p) const;
289	protected:
290	virtual Double_t GetValue(AliAODPair* /pair/) const {return 0.0;}
291	ClassDef(AliAODOutSideSameSignCut,1)
292	};
293	/******************************************************************/
294
295	class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
296	{
297	public:
298	AliAODOutSideDiffSignCut(){}
299	virtual ~AliAODOutSideDiffSignCut(){}
300	virtual Bool_t Rejected(AliAODPair *p) const;
301	protected:
302	virtual Double_t GetValue(AliAODPair* /pair/) const {return 0.0;}
303	ClassDef(AliAODOutSideDiffSignCut,1)
304	};
305	/******************************************************************/
306
307	class AliAODLogicalOperPairCut: public AliAODPairBaseCut
308	{
309	public:
310	AliAODLogicalOperPairCut();
311	AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
312	virtual ~AliAODLogicalOperPairCut();
313	protected:
314	Double_t GetValue(AliAODPair * /pair/) const {MayNotUse("GetValue");return 0.0;}
315
316	AliAODPairBaseCut* fFirst; //second cut
317	AliAODPairBaseCut* fSecond; //first cut
318	private:
319	class AliAODDummyBasePairCut: public AliAODPairBaseCut
320	{
321	Double_t GetValue(AliAODPair* /pair/) const {return 0.0;}
322	Bool_t Rejected(AliAODPair* /pair/) const;
323	};
324
325	ClassDef(AliAODLogicalOperPairCut,1)
326	};
327	/******************************************************************/
328
329	class AliAODOrPairCut: public AliAODLogicalOperPairCut
330	{
331	public:
332	AliAODOrPairCut(){}
333	AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
334	virtual ~AliAODOrPairCut(){}
335	Bool_t Rejected(AliAODPair *p) const;
336	ClassDef(AliAODOrPairCut,1)
337	};
338	/******************************************************************/
339
340	class AliAODAndPairCut: public AliAODLogicalOperPairCut
341	{
342	public:
343	AliAODAndPairCut(){}
344	AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
345	virtual ~AliAODAndPairCut(){}
346	Bool_t Rejected(AliAODPair *p) const;
347	ClassDef(AliAODAndPairCut,1)
348	};
349
350	#endif