[u/mrichter/AliRoot.git] / HBTAN / AliHBTPairCut.h

#ifndef ALIHBTPAIRCUT_H
#define ALIHBTPAIRCUT_H

/* $Id$ */

//Piotr Skowronski@cern.ch
//Class implements cut on the pair of particles
//
//more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
 
#include "AliHBTPair.h"

class AliHBTParticleCut;
class AliHbtBasePairCut;

enum AliHBTPairCutProperty
{
  kHbtPairCutPropQInv, //Q invariant
  kHbtPairCutPropKt,
  kHbtPairCutPropKStar,
  kHbtPairCutPropQSideCMSLC,
  kHbtPairCutPropQOutCMSLC,
  kHbtPairCutPropQLongCMSLC,
  kHbtPairCutPropDeltaPhi,
  kHbtPairCutPropDeltaTheta,
  kHbtPairCutPropDeltaP,
  kHbtPairCutPropDeltaPt,
  kHbtPairCutPropAvSepar,
  kHbtPairCutPropSepar,
  kHbtPairCutPropClOverlap,
  kHbtPairCutPropPixelSepar,
  kHbtPairCutPropNone
};
/******************************************************************/

class AliHBTPairCut: public TNamed
{
 public:
  AliHBTPairCut();
  AliHBTPairCut(const AliHBTPairCut& in);
  AliHBTPairCut& operator = (const AliHBTPairCut& in);
  
  virtual ~AliHBTPairCut();
  virtual Bool_t Pass(AliHBTPair* pair) const;
  virtual Bool_t PassPairProp(AliHBTPair* pair) const;
     
  virtual Bool_t IsEmpty() const {return kFALSE;}
  void SetFirstPartCut(AliHBTParticleCut* cut);  //sets the cut on the first particle
  void SetSecondPartCut(AliHBTParticleCut* cut); //sets the cut on the second particle
  
  void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
  
  virtual void AddBasePairCut(AliHbtBasePairCut* cut);
  
  virtual void Print();
  
  void SetQInvRange(Double_t min, Double_t max);
  void SetKtRange(Double_t min, Double_t max);
  void SetKStarRange(Double_t min, Double_t max);
  void SetQOutCMSLRange(Double_t min, Double_t max);
  void SetQSideCMSLRange(Double_t min, Double_t max);
  void SetQLongCMSLRange(Double_t min, Double_t max);
  void SetAvSeparationRange(Double_t min,Double_t max = 10e5);//Anti-Merging Cut
  void SetITSSeparation(Int_t layer, Double_t drphi=0.01,Double_t dz = 0.08);//Anti-Merging Cut for first pixel layer
  void SetClusterOverlapRange(Double_t min,Double_t max);//Anti-Splitting Max range -0.5 1.0
      
  AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
  AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
  
 protected:
  AliHBTParticleCut*      fFirstPartCut;//cut on first particle in pair
  AliHBTParticleCut*      fSecondPartCut;//cut on second particle in pair
  
  AliHbtBasePairCut** fCuts; //! array of poiters to base cuts
  Int_t fNCuts;//Number of cuts in fCuts array
  
  
  AliHbtBasePairCut* FindCut(AliHBTPairCutProperty cut);
 private:
  static const Int_t fgkMaxCuts; // Max number of cuts
  ClassDef(AliHBTPairCut,2)
};
/******************************************************************/
/******************************************************************/
/******************************************************************/

class AliHBTEmptyPairCut:  public AliHBTPairCut
{
  //Empty - it passes possitively all particles - it means returns always False
  //Class describing cut on pairs of particles
 public:
  AliHBTEmptyPairCut(){};
  AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
  virtual ~AliHBTEmptyPairCut(){};
  
  Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything
  Bool_t IsEmpty() const {return kTRUE;}
  
  ClassDef(AliHBTEmptyPairCut,1)
};


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

class AliHbtBasePairCut: public TObject
{
  //This class defines the range of some property - pure virtual
  //Property is coded by AliHBTCutTypes type
   
 public:
     
  AliHbtBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliHBTPairCutProperty prop= kHbtPairCutPropNone):
    fMin(min),fMax(max),fProperty(prop){}
  
  virtual   ~AliHbtBasePairCut(){}
     
  virtual Bool_t    Pass(AliHBTPair* 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;}
  
  AliHBTPairCutProperty GetProperty() const {return fProperty;}
  
 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const = 0;
  
  Double_t fMin; // Lower boundary of the range
  Double_t fMax; // Upper boundary of the range
  
  AliHBTPairCutProperty fProperty; // The property itself
  
  ClassDef(AliHbtBasePairCut,1)
 
 };
/******************************************************************/

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

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

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

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

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

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

class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
{
 public:
  AliHBTQSideCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
    AliHbtBasePairCut(min,max,kHbtPairCutPropQSideCMSLC){}
  virtual ~AliHBTQSideCMSLCCut(){}
 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const 
    {return pair->GetQSideCMSLC();}

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


class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
{
 public:
  AliHBTQOutCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
    AliHbtBasePairCut(min,max,kHbtPairCutPropQOutCMSLC){}
  virtual ~AliHBTQOutCMSLCCut(){}
 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const 
    {return pair->GetQOutCMSLC();}
  
  ClassDef(AliHBTQOutCMSLCCut,1)
};
/******************************************************************/

class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
{
 public:
  AliHBTQLongCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
    AliHbtBasePairCut(min,max,kHbtPairCutPropQLongCMSLC){}
  virtual ~AliHBTQLongCMSLCCut(){}
 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const 
    {return pair->GetQLongCMSLC();}

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

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

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

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

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

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

 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const;
  ClassDef(AliHBTCluterOverlapCut,1)
};
/******************************************************************/
  
class AliHBTAvSeparationCut: public AliHbtBasePairCut
{
 public:
  AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
    AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
  virtual ~AliHBTAvSeparationCut(){}
  
 protected:
  virtual Double_t  GetValue(AliHBTPair* pair) const;
  ClassDef(AliHBTAvSeparationCut,1)
};
/******************************************************************/
  
class AliHBTSeparationCut: public AliHbtBasePairCut
{
 public:
  AliHBTSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
    AliHbtBasePairCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
  virtual ~AliHBTSeparationCut(){}
  
 protected:
  Int_t fPoint;//index of the point that distance should be measured
  virtual Double_t  GetValue(AliHBTPair* pair) const;
  ClassDef(AliHBTSeparationCut,1)
};
/******************************************************************/
  
class AliHBTITSSeparationCut: public AliHbtBasePairCut
{
//Anti merging cut for the first layer of pixels
 public:
  AliHBTITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
    AliHbtBasePairCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
  virtual ~AliHBTITSSeparationCut(){}
  Bool_t   Pass(AliHBTPair* 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(AliHBTPair* /*pair*/) const {return 0.0;}//not used
  ClassDef(AliHBTITSSeparationCut,1)
};
/******************************************************************/

class AliHBTOutSideSameSignCut: public AliHbtBasePairCut
{
 public:
  AliHBTOutSideSameSignCut(){}
  virtual ~AliHBTOutSideSameSignCut(){}
  virtual Bool_t Pass(AliHBTPair *p) const;
 protected:
  virtual Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
  ClassDef(AliHBTOutSideSameSignCut,1)
};
/******************************************************************/

class AliHBTOutSideDiffSignCut: public AliHbtBasePairCut
{
 public:
  AliHBTOutSideDiffSignCut(){}
  virtual ~AliHBTOutSideDiffSignCut(){}
  virtual Bool_t Pass(AliHBTPair *p) const;
 protected:
  virtual Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
  ClassDef(AliHBTOutSideDiffSignCut,1)
};
/******************************************************************/

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

     AliHbtBasePairCut* fFirst;   //second cut
     AliHbtBasePairCut* fSecond;  //first cut
   private:
    class  AliHBTDummyBasePairCut: public AliHbtBasePairCut
     {
       Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
       Bool_t    Pass(AliHBTPair* /*pair*/) const;
     };

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

class AliHBTOrPairCut: public AliHBTLogicalOperPairCut
{
   public:
     AliHBTOrPairCut(){}
     AliHBTOrPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
     virtual   ~AliHBTOrPairCut(){}
     Bool_t    Pass(AliHBTPair *p) const;
     ClassDef(AliHBTOrPairCut,1)
};
/******************************************************************/

class AliHBTAndPairCut: public AliHBTLogicalOperPairCut
{
   public:
     AliHBTAndPairCut(){}
     AliHBTAndPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
     virtual   ~AliHBTAndPairCut(){}
     Bool_t    Pass(AliHBTPair *p) const;
     ClassDef(AliHBTAndPairCut,1)
};

#endif
Commit	Line	Data
1b446896	1	#ifndef ALIHBTPAIRCUT_H
	2	#define ALIHBTPAIRCUT_H
	3
ea197c3e	4	/* $Id$ */
1b446896	5
ea197c3e	6	//Piotr Skowronski@cern.ch
	7	//Class implements cut on the pair of particles
	8	//
	9	//more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
	10
1b446896	11	#include "AliHBTPair.h"
1b446896	12
ea197c3e	13	class AliHBTParticleCut;
1b446896	14	class AliHbtBasePairCut;
	15
	16	enum AliHBTPairCutProperty
ea197c3e	17	{
1b446896	18	kHbtPairCutPropQInv, //Q invariant
bce80f3b	19	kHbtPairCutPropKt,
e3131968	20	kHbtPairCutPropKStar,
2d5d4d7d	21	kHbtPairCutPropQSideCMSLC,
	22	kHbtPairCutPropQOutCMSLC,
	23	kHbtPairCutPropQLongCMSLC,
879e0c18	24	kHbtPairCutPropDeltaPhi,
	25	kHbtPairCutPropDeltaTheta,
	26	kHbtPairCutPropDeltaP,
	27	kHbtPairCutPropDeltaPt,
9616170a	28	kHbtPairCutPropAvSepar,
6e8b6371	29	kHbtPairCutPropSepar,
66d1d1a4	30	kHbtPairCutPropClOverlap,
8cb21125	31	kHbtPairCutPropPixelSepar,
1b446896	32	kHbtPairCutPropNone
ea197c3e	33	};
49d1e071	34	/******************************************************************/
1b446896	35
80482463	36	class AliHBTPairCut: public TNamed
1b446896	37	{
ea197c3e	38	public:
	39	AliHBTPairCut();
	40	AliHBTPairCut(const AliHBTPairCut& in);
	41	AliHBTPairCut& operator = (const AliHBTPairCut& in);
	42
	43	virtual ~AliHBTPairCut();
	44	virtual Bool_t Pass(AliHBTPair* pair) const;
	45	virtual Bool_t PassPairProp(AliHBTPair* pair) const;
48704f50	46
ea197c3e	47	virtual Bool_t IsEmpty() const {return kFALSE;}
	48	void SetFirstPartCut(AliHBTParticleCut* cut); //sets the cut on the first particle
	49	void SetSecondPartCut(AliHBTParticleCut* cut); //sets the cut on the second particle
	50
	51	void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
	52
28cf76fa	53	virtual void AddBasePairCut(AliHbtBasePairCut* cut);
ea197c3e	54
8cb21125	55	virtual void Print();
8cb21125	56
ea197c3e	57	void SetQInvRange(Double_t min, Double_t max);
	58	void SetKtRange(Double_t min, Double_t max);
	59	void SetKStarRange(Double_t min, Double_t max);
	60	void SetQOutCMSLRange(Double_t min, Double_t max);
	61	void SetQSideCMSLRange(Double_t min, Double_t max);
	62	void SetQLongCMSLRange(Double_t min, Double_t max);
66d1d1a4	63	void SetAvSeparationRange(Double_t min,Double_t max = 10e5);//Anti-Merging Cut
650aa30d	64	void SetITSSeparation(Int_t layer, Double_t drphi=0.01,Double_t dz = 0.08);//Anti-Merging Cut for first pixel layer
66d1d1a4	65	void SetClusterOverlapRange(Double_t min,Double_t max);//Anti-Splitting Max range -0.5 1.0
9616170a	66
ea197c3e	67	AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
	68	AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
	69
	70	protected:
	71	AliHBTParticleCut* fFirstPartCut;//cut on first particle in pair
	72	AliHBTParticleCut* fSecondPartCut;//cut on second particle in pair
	73
	74	AliHbtBasePairCut** fCuts; //! array of poiters to base cuts
	75	Int_t fNCuts;//Number of cuts in fCuts array
	76
	77
	78	AliHbtBasePairCut* FindCut(AliHBTPairCutProperty cut);
	79	private:
	80	static const Int_t fgkMaxCuts; // Max number of cuts
ea197c3e	81	ClassDef(AliHBTPairCut,2)
1b446896	82	};
	83	/******************************************************************/
	84	/******************************************************************/
	85	/******************************************************************/
	86
	87	class AliHBTEmptyPairCut: public AliHBTPairCut
	88	{
ea197c3e	89	//Empty - it passes possitively all particles - it means returns always False
	90	//Class describing cut on pairs of particles
	91	public:
	92	AliHBTEmptyPairCut(){};
28cf76fa	93	AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
ea197c3e	94	virtual ~AliHBTEmptyPairCut(){};
	95
	96	Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything
	97	Bool_t IsEmpty() const {return kTRUE;}
	98
	99	ClassDef(AliHBTEmptyPairCut,1)
1b446896	100	};
	101
	102
	103
	104	/******************************************************************/
	105	/******************************************************************/
	106	/******************************************************************/
	107
	108	class AliHbtBasePairCut: public TObject
ea197c3e	109	{
	110	//This class defines the range of some property - pure virtual
	111	//Property is coded by AliHBTCutTypes type
1b446896	112
ea197c3e	113	public:
1b446896	114
ea197c3e	115	AliHbtBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliHBTPairCutProperty prop= kHbtPairCutPropNone):
	116	fMin(min),fMax(max),fProperty(prop){}
	117
	118	virtual ~AliHbtBasePairCut(){}
1b446896	119
49d1e071	120	virtual Bool_t Pass(AliHBTPair* pair) const;
ea197c3e	121
	122	void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
	123
	124	void SetMinimum(Double_t min){fMin = min;}
	125	void SetMaximum(Double_t max){fMax = max;}
	126
	127	Double_t GetMinimum() const {return fMin;}
	128	Double_t GetMaximum() const {return fMax;}
	129
	130	AliHBTPairCutProperty GetProperty() const {return fProperty;}
	131
	132	protected:
	133	virtual Double_t GetValue(AliHBTPair* pair) const = 0;
	134
	135	Double_t fMin; // Lower boundary of the range
	136	Double_t fMax; // Upper boundary of the range
	137
	138	AliHBTPairCutProperty fProperty; // The property itself
	139
	140	ClassDef(AliHbtBasePairCut,1)
	141
1b446896	142	};
49d1e071	143	/******************************************************************/
1b446896	144
ea197c3e	145	inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
ea197c3e	146	{
9616170a	147	//checks if pair proprty is in range
	148	//null pointer check is made by AliHBTPairCut, so here is unnecesary
	149
ea197c3e	150	Double_t value = GetValue(pair);
	151	if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
	152	else return kTRUE; //rejected
	153	}
1b446896	154	/******************************************************************/
	155	/******************************************************************/
	156	/******************************************************************/
49d1e071	157
1b446896	158	class AliHBTQInvCut: public AliHbtBasePairCut
ea197c3e	159	{
	160	public:
	161	AliHBTQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropQInv){}
	162	virtual ~AliHBTQInvCut(){}
	163	protected:
	164	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetQInv();}
	165
	166	ClassDef(AliHBTQInvCut,1)
1b446896	167	};
49d1e071	168	/******************************************************************/
bce80f3b	169
ea197c3e	170	class AliHBTKtCut: public AliHbtBasePairCut {
	171	public:
	172	AliHBTKtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKt){}
	173	virtual ~AliHBTKtCut(){}
	174	protected:
	175	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetKt();}
	176
	177	ClassDef(AliHBTKtCut,1)
bce80f3b	178	};
49d1e071	179	/******************************************************************/
bce80f3b	180
e3131968	181	class AliHBTKStarCut: public AliHbtBasePairCut
ea197c3e	182	{
	183	public:
	184	AliHBTKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKStar){}
	185	virtual ~AliHBTKStarCut(){}
	186	protected:
	187	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetKStar();}
	188
	189	ClassDef(AliHBTKStarCut,1)
	190	};
49d1e071	191	/******************************************************************/
2d5d4d7d	192
2d5d4d7d	193	class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
ea197c3e	194	{
	195	public:
	196	AliHBTQSideCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	197	AliHbtBasePairCut(min,max,kHbtPairCutPropQSideCMSLC){}
	198	virtual ~AliHBTQSideCMSLCCut(){}
	199	protected:
	200	virtual Double_t GetValue(AliHBTPair* pair) const
	201	{return pair->GetQSideCMSLC();}
	202
	203	ClassDef(AliHBTQSideCMSLCCut,1)
	204	};
49d1e071	205	/******************************************************************/
2d5d4d7d	206
	207
	208	class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
ea197c3e	209	{
	210	public:
	211	AliHBTQOutCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	212	AliHbtBasePairCut(min,max,kHbtPairCutPropQOutCMSLC){}
	213	virtual ~AliHBTQOutCMSLCCut(){}
	214	protected:
	215	virtual Double_t GetValue(AliHBTPair* pair) const
	216	{return pair->GetQOutCMSLC();}
	217
	218	ClassDef(AliHBTQOutCMSLCCut,1)
	219	};
49d1e071	220	/******************************************************************/
2d5d4d7d	221
2d5d4d7d	222	class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
ea197c3e	223	{
	224	public:
	225	AliHBTQLongCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	226	AliHbtBasePairCut(min,max,kHbtPairCutPropQLongCMSLC){}
	227	virtual ~AliHBTQLongCMSLCCut(){}
	228	protected:
	229	virtual Double_t GetValue(AliHBTPair* pair) const
	230	{return pair->GetQLongCMSLC();}
	231
	232	ClassDef(AliHBTQLongCMSLCCut,1)
	233	};
49d1e071	234	/******************************************************************/
879e0c18	235
	236	class AliHBTDeltaPhiCut: public AliHbtBasePairCut
	237	{
	238	public:
	239	AliHBTDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
	240	AliHbtBasePairCut(min,max,kHbtPairCutPropDeltaPhi){}
	241	virtual ~AliHBTDeltaPhiCut(){}
	242	protected:
	243	virtual Double_t GetValue(AliHBTPair* pair) const
	244	{return TMath::Abs(pair->GetDeltaPhi());}
	245
	246	ClassDef(AliHBTDeltaPhiCut,1)
	247	};
	248	/******************************************************************/
	249
	250	class AliHBTDeltaThetaCut: public AliHbtBasePairCut
	251	{
	252	public:
	253	AliHBTDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
	254	AliHbtBasePairCut(min,max,kHbtPairCutPropDeltaTheta){}
	255	virtual ~AliHBTDeltaThetaCut(){}
	256	protected:
	257	virtual Double_t GetValue(AliHBTPair* pair) const
	258	{return TMath::Abs(pair->GetDeltaTheta());}
	259
	260	ClassDef(AliHBTDeltaThetaCut,1)
	261	};
	262	/******************************************************************/
ed20b0ba	263
	264	class AliHBTCluterOverlapCut: public AliHbtBasePairCut
	265	{
	266	public:
	267	AliHBTCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
	268	AliHbtBasePairCut(min,max,kHbtPairCutPropClOverlap){}
	269	virtual ~AliHBTCluterOverlapCut(){}
	270
	271	protected:
	272	virtual Double_t GetValue(AliHBTPair* pair) const;
	273	ClassDef(AliHBTCluterOverlapCut,1)
	274	};
	275	/******************************************************************/
9616170a	276
	277	class AliHBTAvSeparationCut: public AliHbtBasePairCut
	278	{
	279	public:
	280	AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
	281	AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
	282	virtual ~AliHBTAvSeparationCut(){}
	283
	284	protected:
	285	virtual Double_t GetValue(AliHBTPair* pair) const;
	286	ClassDef(AliHBTAvSeparationCut,1)
	287	};
49d1e071	288	/******************************************************************/
8cb21125	289
6e8b6371	290	class AliHBTSeparationCut: public AliHbtBasePairCut
	291	{
	292	public:
	293	AliHBTSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
	294	AliHbtBasePairCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
	295	virtual ~AliHBTSeparationCut(){}
	296
	297	protected:
	298	Int_t fPoint;//index of the point that distance should be measured
	299	virtual Double_t GetValue(AliHBTPair* pair) const;
	300	ClassDef(AliHBTSeparationCut,1)
	301	};
	302	/******************************************************************/
	303
650aa30d	304	class AliHBTITSSeparationCut: public AliHbtBasePairCut
8cb21125	305	{
	306	//Anti merging cut for the first layer of pixels
	307	public:
92d472ba	308	AliHBTITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
650aa30d	309	AliHbtBasePairCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
650aa30d	310	virtual ~AliHBTITSSeparationCut(){}
8cb21125	311	Bool_t Pass(AliHBTPair* pair) const;
650aa30d	312	Int_t GetLayer() const {return fLayer;}
8cb21125	313	protected:
650aa30d	314	Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
8cb21125	315	virtual Double_t GetValue(AliHBTPair* /pair/) const {return 0.0;}//not used
650aa30d	316	ClassDef(AliHBTITSSeparationCut,1)
8cb21125	317	};
8cb21125	318	/******************************************************************/
66d1d1a4	319
ed20b0ba	320	class AliHBTOutSideSameSignCut: public AliHbtBasePairCut
66d1d1a4	321	{
66d1d1a4	322	public:
ed20b0ba	323	AliHBTOutSideSameSignCut(){}
	324	virtual ~AliHBTOutSideSameSignCut(){}
	325	virtual Bool_t Pass(AliHBTPair *p) const;
66d1d1a4	326	protected:
f9bf3968	327	virtual Double_t GetValue(AliHBTPair* /pair/) const {return 0.0;}
ed20b0ba	328	ClassDef(AliHBTOutSideSameSignCut,1)
	329	};
	330	/******************************************************************/
	331
	332	class AliHBTOutSideDiffSignCut: public AliHbtBasePairCut
	333	{
	334	public:
	335	AliHBTOutSideDiffSignCut(){}
	336	virtual ~AliHBTOutSideDiffSignCut(){}
	337	virtual Bool_t Pass(AliHBTPair *p) const;
	338	protected:
f9bf3968	339	virtual Double_t GetValue(AliHBTPair* /pair/) const {return 0.0;}
ed20b0ba	340	ClassDef(AliHBTOutSideDiffSignCut,1)
66d1d1a4	341	};
49d1e071	342	/******************************************************************/
	343
	344	class AliHBTLogicalOperPairCut: public AliHbtBasePairCut
	345	{
	346	public:
	347	AliHBTLogicalOperPairCut();
	348	AliHBTLogicalOperPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second);
	349	virtual ~AliHBTLogicalOperPairCut();
	350	protected:
	351	Double_t GetValue(AliHBTPair * /pair/) const {MayNotUse("GetValue");return 0.0;}
	352
	353	AliHbtBasePairCut* fFirst; //second cut
	354	AliHbtBasePairCut* fSecond; //first cut
	355	private:
	356	class AliHBTDummyBasePairCut: public AliHbtBasePairCut
	357	{
	358	Double_t GetValue(AliHBTPair* /pair/) const {return 0.0;}
	359	Bool_t Pass(AliHBTPair* /pair/) const;
	360	};
	361
	362	ClassDef(AliHBTLogicalOperPairCut,1)
	363	};
	364	/******************************************************************/
	365
	366	class AliHBTOrPairCut: public AliHBTLogicalOperPairCut
	367	{
	368	public:
	369	AliHBTOrPairCut(){}
	370	AliHBTOrPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
	371	virtual ~AliHBTOrPairCut(){}
	372	Bool_t Pass(AliHBTPair *p) const;
	373	ClassDef(AliHBTOrPairCut,1)
	374	};
	375	/******************************************************************/
	376
	377	class AliHBTAndPairCut: public AliHBTLogicalOperPairCut
	378	{
	379	public:
	380	AliHBTAndPairCut(){}
	381	AliHBTAndPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
	382	virtual ~AliHBTAndPairCut(){}
	383	Bool_t Pass(AliHBTPair *p) const;
	384	ClassDef(AliHBTAndPairCut,1)
	385	};
	386
1b446896	387	#endif