[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,
  kHbtPairCutPropAvSepar,
  kHbtPairCutPropClOverlap,
  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);
  
  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 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(){}
     
  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 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 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)
};
  
#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,
9616170a	24	kHbtPairCutPropAvSepar,
66d1d1a4	25	kHbtPairCutPropClOverlap,
1b446896	26	kHbtPairCutPropNone
ea197c3e	27	};
1b446896	28
80482463	29	class AliHBTPairCut: public TNamed
1b446896	30	{
ea197c3e	31	public:
	32	AliHBTPairCut();
	33	AliHBTPairCut(const AliHBTPairCut& in);
	34	AliHBTPairCut& operator = (const AliHBTPairCut& in);
	35
	36	virtual ~AliHBTPairCut();
	37	virtual Bool_t Pass(AliHBTPair* pair) const;
	38	virtual Bool_t PassPairProp(AliHBTPair* pair) const;
48704f50	39
ea197c3e	40	virtual Bool_t IsEmpty() const {return kFALSE;}
	41	void SetFirstPartCut(AliHBTParticleCut* cut); //sets the cut on the first particle
	42	void SetSecondPartCut(AliHBTParticleCut* cut); //sets the cut on the second particle
	43
	44	void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
	45
28cf76fa	46	virtual void AddBasePairCut(AliHbtBasePairCut* cut);
ea197c3e	47
	48	void SetQInvRange(Double_t min, Double_t max);
	49	void SetKtRange(Double_t min, Double_t max);
	50	void SetKStarRange(Double_t min, Double_t max);
	51	void SetQOutCMSLRange(Double_t min, Double_t max);
	52	void SetQSideCMSLRange(Double_t min, Double_t max);
	53	void SetQLongCMSLRange(Double_t min, Double_t max);
66d1d1a4	54	void SetAvSeparationRange(Double_t min,Double_t max = 10e5);//Anti-Merging Cut
66d1d1a4	55	void SetClusterOverlapRange(Double_t min,Double_t max);//Anti-Splitting Max range -0.5 1.0
9616170a	56
ea197c3e	57	AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
	58	AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
	59
	60	protected:
	61	AliHBTParticleCut* fFirstPartCut;//cut on first particle in pair
	62	AliHBTParticleCut* fSecondPartCut;//cut on second particle in pair
	63
	64	AliHbtBasePairCut** fCuts; //! array of poiters to base cuts
	65	Int_t fNCuts;//Number of cuts in fCuts array
	66
	67
	68	AliHbtBasePairCut* FindCut(AliHBTPairCutProperty cut);
	69	private:
	70	static const Int_t fgkMaxCuts; // Max number of cuts
ea197c3e	71	ClassDef(AliHBTPairCut,2)
1b446896	72	};
	73	/******************************************************************/
	74	/******************************************************************/
	75	/******************************************************************/
	76
	77	class AliHBTEmptyPairCut: public AliHBTPairCut
	78	{
ea197c3e	79	//Empty - it passes possitively all particles - it means returns always False
	80	//Class describing cut on pairs of particles
	81	public:
	82	AliHBTEmptyPairCut(){};
28cf76fa	83	AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
ea197c3e	84	virtual ~AliHBTEmptyPairCut(){};
	85
	86	Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything
	87	Bool_t IsEmpty() const {return kTRUE;}
	88
	89	ClassDef(AliHBTEmptyPairCut,1)
1b446896	90	};
	91
	92
	93
	94	/******************************************************************/
	95	/******************************************************************/
	96	/******************************************************************/
	97
	98	class AliHbtBasePairCut: public TObject
ea197c3e	99	{
	100	//This class defines the range of some property - pure virtual
	101	//Property is coded by AliHBTCutTypes type
1b446896	102
ea197c3e	103	public:
1b446896	104
ea197c3e	105	AliHbtBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliHBTPairCutProperty prop= kHbtPairCutPropNone):
	106	fMin(min),fMax(max),fProperty(prop){}
	107
	108	virtual ~AliHbtBasePairCut(){}
1b446896	109
ea197c3e	110	Bool_t Pass(AliHBTPair* pair) const;
	111
	112	void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
	113
	114	void SetMinimum(Double_t min){fMin = min;}
	115	void SetMaximum(Double_t max){fMax = max;}
	116
	117	Double_t GetMinimum() const {return fMin;}
	118	Double_t GetMaximum() const {return fMax;}
	119
	120	AliHBTPairCutProperty GetProperty() const {return fProperty;}
	121
	122	protected:
	123	virtual Double_t GetValue(AliHBTPair* pair) const = 0;
	124
	125	Double_t fMin; // Lower boundary of the range
	126	Double_t fMax; // Upper boundary of the range
	127
	128	AliHBTPairCutProperty fProperty; // The property itself
	129
	130	ClassDef(AliHbtBasePairCut,1)
	131
1b446896	132	};
1b446896	133
ea197c3e	134	inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
ea197c3e	135	{
9616170a	136	//checks if pair proprty is in range
	137	//null pointer check is made by AliHBTPairCut, so here is unnecesary
	138
ea197c3e	139	Double_t value = GetValue(pair);
	140	if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
	141	else return kTRUE; //rejected
	142	}
1b446896	143	/******************************************************************/
	144	/******************************************************************/
	145	/******************************************************************/
	146	class AliHBTQInvCut: public AliHbtBasePairCut
ea197c3e	147	{
	148	public:
	149	AliHBTQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropQInv){}
	150	virtual ~AliHBTQInvCut(){}
	151	protected:
	152	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetQInv();}
	153
	154	ClassDef(AliHBTQInvCut,1)
1b446896	155	};
1b446896	156
bce80f3b	157
ea197c3e	158	class AliHBTKtCut: public AliHbtBasePairCut {
	159	public:
	160	AliHBTKtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKt){}
	161	virtual ~AliHBTKtCut(){}
	162	protected:
	163	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetKt();}
	164
	165	ClassDef(AliHBTKtCut,1)
bce80f3b	166	};
bce80f3b	167
e3131968	168	class AliHBTKStarCut: public AliHbtBasePairCut
ea197c3e	169	{
	170	public:
	171	AliHBTKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKStar){}
	172	virtual ~AliHBTKStarCut(){}
	173	protected:
	174	virtual Double_t GetValue(AliHBTPair* pair) const {return pair->GetKStar();}
	175
	176	ClassDef(AliHBTKStarCut,1)
	177	};
2d5d4d7d	178
2d5d4d7d	179	class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
ea197c3e	180	{
	181	public:
	182	AliHBTQSideCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	183	AliHbtBasePairCut(min,max,kHbtPairCutPropQSideCMSLC){}
	184	virtual ~AliHBTQSideCMSLCCut(){}
	185	protected:
	186	virtual Double_t GetValue(AliHBTPair* pair) const
	187	{return pair->GetQSideCMSLC();}
	188
	189	ClassDef(AliHBTQSideCMSLCCut,1)
	190	};
2d5d4d7d	191
	192
	193	class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
ea197c3e	194	{
	195	public:
	196	AliHBTQOutCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	197	AliHbtBasePairCut(min,max,kHbtPairCutPropQOutCMSLC){}
	198	virtual ~AliHBTQOutCMSLCCut(){}
	199	protected:
	200	virtual Double_t GetValue(AliHBTPair* pair) const
	201	{return pair->GetQOutCMSLC();}
	202
	203	ClassDef(AliHBTQOutCMSLCCut,1)
	204	};
2d5d4d7d	205
2d5d4d7d	206	class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
ea197c3e	207	{
	208	public:
	209	AliHBTQLongCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
	210	AliHbtBasePairCut(min,max,kHbtPairCutPropQLongCMSLC){}
	211	virtual ~AliHBTQLongCMSLCCut(){}
	212	protected:
	213	virtual Double_t GetValue(AliHBTPair* pair) const
	214	{return pair->GetQLongCMSLC();}
	215
	216	ClassDef(AliHBTQLongCMSLCCut,1)
	217	};
2d5d4d7d	218
9616170a	219
	220	class AliHBTAvSeparationCut: public AliHbtBasePairCut
	221	{
	222	public:
	223	AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
	224	AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
	225	virtual ~AliHBTAvSeparationCut(){}
	226
	227	protected:
	228	virtual Double_t GetValue(AliHBTPair* pair) const;
	229	ClassDef(AliHBTAvSeparationCut,1)
	230	};
66d1d1a4	231
	232	class AliHBTCluterOverlapCut: public AliHbtBasePairCut
	233	{
	234	public:
	235	AliHBTCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
	236	AliHbtBasePairCut(min,max,kHbtPairCutPropClOverlap){}
	237	virtual ~AliHBTCluterOverlapCut(){}
	238
	239	protected:
	240	virtual Double_t GetValue(AliHBTPair* pair) const;
	241	ClassDef(AliHBTCluterOverlapCut,1)
	242	};
9616170a	243
1b446896	244	#endif