[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,
      kHbtPairCutPropKStarOut,
      kHbtPairCutPropKStarSide,
      kHbtPairCutPropKStarLong,
      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 AliAODKStarOutCut: public AliAODPairBaseCut
{
 public:
  AliAODKStarOutCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStarOut){}
  virtual ~AliAODKStarOutCut(){}
 protected:
  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStarOut();}

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

  ClassDef(AliAODKStarSideCut,1)
};

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

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

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