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

#ifndef ALIHBTPIDPURITYFCTNS_H
#define ALIHBTPIDPURITYFCTNS_H
//_______________________________________________________________________________
/////////////////////////////////////////////////////////////////////////////////
//
// class AliHBTMonPIDPurityVsPtFctn;
// class AliHBTMonThetaResolutionVsPtFctn;
//
// file: AliHBTPIDPurityFctns.cxx AliHBTPIDPurityFctns.h
//
// Classes for calculating PID purity, efficiency and other things connected with PID
// xxxxxxxxxx
// xxxxxxxxxx
// xxxxxxxxxx
// xxxxxxxxxx
// xxxxxxxxxx
//
// added by Piotr.Skowronski@cern.ch
//
//////////////////////////////////////////////////////////////////////////////////

#include "AliHBTFunction.h"
#include "AliHBTMonitorFunction.h"

class AliHBTMonPIDPurityVsPtFctn: public AliHBTMonTwoParticleFctn1D, public AliHBTCorrelFunction
{
  public: 
    AliHBTMonPIDPurityVsPtFctn(Int_t nbins = 20, Double_t maxXval = 2.0, Double_t minXval = 0.0);
    AliHBTMonPIDPurityVsPtFctn(const AliHBTMonPIDPurityVsPtFctn& /*in*/);
    virtual ~AliHBTMonPIDPurityVsPtFctn();
    
    AliHBTMonPIDPurityVsPtFctn& operator=(const AliHBTMonPIDPurityVsPtFctn& /*in*/);
    
    void Init();
    Int_t Write(const char* /*x1*/ = "",Int_t /*x2*/ = 0, Int_t /*x3*/ = 0);
    Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return AliHBTMonTwoParticleFctn1D::Write(x1,x2,x3);}
    void Rename(const Char_t * name);
    void Rename(const Char_t * name, const Char_t * title);
    TH1* GetResult();
    Double_t GetValue(AliVAODParticle * /*track*/,AliVAODParticle * /*part*/) const { return 0.0; }
    void Process(AliVAODParticle * track,AliVAODParticle * part);
  protected:
    TH1D* fGood;//histogram filled with correctly identified particles
    TH1D* fAll;//histogram filled with all particles
    ClassDef(AliHBTMonPIDPurityVsPtFctn,1)
};
/***********************************************************************/

class AliHBTMonPIDContaminationVsPtFctn: public AliHBTMonTwoParticleFctn1D, public AliHBTCorrelFunction
{
  public: 
    AliHBTMonPIDContaminationVsPtFctn(Int_t nbins = 20, Double_t maxXval = 2.0, Double_t minXval = 0.0);
    AliHBTMonPIDContaminationVsPtFctn(const AliHBTMonPIDContaminationVsPtFctn& /*in*/);
    virtual ~AliHBTMonPIDContaminationVsPtFctn();    

    AliHBTMonPIDContaminationVsPtFctn& operator=(const AliHBTMonPIDContaminationVsPtFctn& /*in*/);

    void Init();
    Int_t Write(const char* /*x1*/ = "",Int_t /*x2*/ = 0, Int_t /*x3*/ = 0);
    Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return AliHBTMonTwoParticleFctn1D::Write(x1,x2,x3);}
    void Rename(const Char_t * name);
    void Rename(const Char_t * name, const Char_t * title);
    TH1* GetResult();
    Double_t GetValue(AliVAODParticle * /*track*/,AliVAODParticle * /*part*/) const { return 0.0; }
    void Process(AliVAODParticle * track,AliVAODParticle * part);
  protected:
    TH1D* fWrong;//histogram filled with wrongly identified particles
    TH1D* fAll;//histogram filled with all particles
    ClassDef(AliHBTMonPIDContaminationVsPtFctn,1)
};
/*************************************************************************************/

class AliHBTQInvCorrelFctnPerfectPID: public AliHBTTwoPairFctn1D, public AliHBTCorrelFunction
{
//Q Invaraint Correlation Function
//1D two particle function
//Fills the function only for correctly reconstructed PID
//Together with 
 public:
   AliHBTQInvCorrelFctnPerfectPID(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTQInvCorrelFctnPerfectPID(){};
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   TH1* GetResult();
 protected:
   Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* /*partpair*/) const {return trackpair->GetQInv();}
 private:
   ClassDef(AliHBTQInvCorrelFctnPerfectPID,1)
};

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

class AliHBTWeightQInvCorrelFctnPerfectPID: public AliHBTTwoPairFctn1D, public AliHBTCorrelFunction
{
//Weight Q Invaraint Correlation Function
//1D two particle function
//Fills the function only for correctly reconstructed PID
//Together with regular 
 public:
   AliHBTWeightQInvCorrelFctnPerfectPID(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTWeightQInvCorrelFctnPerfectPID(){};
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   TH1* GetResult();
 protected:
   Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* /*partpair*/) const {return trackpair->GetQInv();}
 private:
   ClassDef(AliHBTWeightQInvCorrelFctnPerfectPID,1)
};
/*************************************************************************************/
class AliHBTWeightQOutSQideQLongFctnPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
{

  public:
    AliHBTWeightQOutSQideQLongFctnPerfectPID(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
                                            Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
                                            Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
    virtual  ~AliHBTWeightQOutSQideQLongFctnPerfectPID(){}

    TH1* GetResult();
    void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
    void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);

  protected:
    void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}

    ClassDef(AliHBTWeightQOutSQideQLongFctnPerfectPID,1)
};

/*************************************************************************************/
class AliHBTQOutSQideQLongFctnPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
{

  public:
    AliHBTQOutSQideQLongFctnPerfectPID(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
                                            Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
                                            Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
    virtual  ~AliHBTQOutSQideQLongFctnPerfectPID(){}

    TH1* GetResult();
    void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
    void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);

  protected:
    void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}

    ClassDef(AliHBTQOutSQideQLongFctnPerfectPID,1)
};


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

class AliHBTPairPIDProbVsQInvFctn: public AliHBTOnePairFctn1D, public AliHBTCorrelFunction
{
//Q Invaraint Correlation Function
//1D two particle function
 public:
   AliHBTPairPIDProbVsQInvFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTPairPIDProbVsQInvFctn(){};
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
   TH1* GetResult();
 protected:
   Double_t GetValue(AliHBTPair * pair) const {return pair->GetQInv();}
 private:
   ClassDef(AliHBTPairPIDProbVsQInvFctn,1)
};
/*************************************************************************************/

class AliHBTPairPIDProbVsQOutSQideQLongFctn: public AliHBTOnePairFctn3D, public AliHBTCorrelFunction
{

  public:
    AliHBTPairPIDProbVsQOutSQideQLongFctn(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
                                          Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
                                          Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
    virtual  ~AliHBTPairPIDProbVsQOutSQideQLongFctn(){}

    TH1* GetResult();
    void ProcessSameEventParticles(AliHBTPair* part);
    void ProcessDiffEventParticles(AliHBTPair* pair);

  protected:
    void GetValues(AliHBTPair* /*pair*/, Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}

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

class AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
 {
  public:
    AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID(Int_t nXbins = 50, Double_t maxXval = 0.3, Double_t minXval = 0.0,
                                    Int_t nYbins = 50, Double_t maxYval = 0.3, Double_t minYval = 0.0,
	                Int_t nZbins = 50, Double_t maxZval = 0.3, Double_t minZval = 0.0);
    virtual ~AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID(){}
    void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
    void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
    
    TH1* GetResult();
  protected:
    void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}
  private:
    ClassDef(AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID,1)
 };
/*************************************************************************************/

class AliHBTPairPIDProbVsPtThetaPhiFctn: public AliHBTOnePairFctn3D, public AliHBTCorrelFunction
{

  public:
    AliHBTPairPIDProbVsPtThetaPhiFctn(Int_t nXbins = 50, Double_t maxXval = 0.3, Double_t minXval = 0.0,
                                      Int_t nYbins = 50, Double_t maxYval = 0.3, Double_t minYval = 0.0,
                                      Int_t nZbins = 50, Double_t maxZval = 0.3, Double_t minZval = 0.0);
    virtual  ~AliHBTPairPIDProbVsPtThetaPhiFctn(){}

    TH1* GetResult();
    void ProcessSameEventParticles(AliHBTPair* part);
    void ProcessDiffEventParticles(AliHBTPair* pair);

  protected:
    void GetValues(AliHBTPair* /*pair*/, Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}

    ClassDef(AliHBTPairPIDProbVsPtThetaPhiFctn,1)
};


#endif
Commit	Line	Data
becde6ce	1	#ifndef ALIHBTPIDPURITYFCTNS_H
	2	#define ALIHBTPIDPURITYFCTNS_H
	3	//_______________________________________________________________________________
	4	/////////////////////////////////////////////////////////////////////////////////
	5	//
	6	// class AliHBTMonPIDPurityVsPtFctn;
	7	// class AliHBTMonThetaResolutionVsPtFctn;
	8	//
	9	// file: AliHBTPIDPurityFctns.cxx AliHBTPIDPurityFctns.h
	10	//
2b31c209	11	// Classes for calculating PID purity, efficiency and other things connected with PID
	12	// xxxxxxxxxx
	13	// xxxxxxxxxx
	14	// xxxxxxxxxx
	15	// xxxxxxxxxx
	16	// xxxxxxxxxx
becde6ce	17	//
becde6ce	18	// added by Piotr.Skowronski@cern.ch
becde6ce	19	//
	20	//////////////////////////////////////////////////////////////////////////////////
	21
	22	#include "AliHBTFunction.h"
	23	#include "AliHBTMonitorFunction.h"
	24
c93e6c76	25	class AliHBTMonPIDPurityVsPtFctn: public AliHBTMonTwoParticleFctn1D, public AliHBTCorrelFunction
becde6ce	26	{
	27	public:
	28	AliHBTMonPIDPurityVsPtFctn(Int_t nbins = 20, Double_t maxXval = 2.0, Double_t minXval = 0.0);
2b31c209	29	AliHBTMonPIDPurityVsPtFctn(const AliHBTMonPIDPurityVsPtFctn& /in/);
becde6ce	30	virtual ~AliHBTMonPIDPurityVsPtFctn();
2b31c209	31
	32	AliHBTMonPIDPurityVsPtFctn& operator=(const AliHBTMonPIDPurityVsPtFctn& /in/);
	33
becde6ce	34	void Init();
3c1edb34	35	Int_t Write(const char* /x1/ = "",Int_t /x2/ = 0, Int_t /x3/ = 0);
3c1edb34	36	Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return AliHBTMonTwoParticleFctn1D::Write(x1,x2,x3);}
becde6ce	37	void Rename(const Char_t * name);
	38	void Rename(const Char_t * name, const Char_t * title);
	39	TH1* GetResult();
78d7c6d3	40	Double_t GetValue(AliVAODParticle * /track/,AliVAODParticle * /part/) const { return 0.0; }
78d7c6d3	41	void Process(AliVAODParticle * track,AliVAODParticle * part);
becde6ce	42	protected:
2b31c209	43	TH1D* fGood;//histogram filled with correctly identified particles
2b31c209	44	TH1D* fAll;//histogram filled with all particles
becde6ce	45	ClassDef(AliHBTMonPIDPurityVsPtFctn,1)
	46	};
	47	/***********************************************************************/
	48
	49	class AliHBTMonPIDContaminationVsPtFctn: public AliHBTMonTwoParticleFctn1D, public AliHBTCorrelFunction
	50	{
	51	public:
	52	AliHBTMonPIDContaminationVsPtFctn(Int_t nbins = 20, Double_t maxXval = 2.0, Double_t minXval = 0.0);
2b31c209	53	AliHBTMonPIDContaminationVsPtFctn(const AliHBTMonPIDContaminationVsPtFctn& /in/);
	54	virtual ~AliHBTMonPIDContaminationVsPtFctn();
	55
	56	AliHBTMonPIDContaminationVsPtFctn& operator=(const AliHBTMonPIDContaminationVsPtFctn& /in/);
	57
becde6ce	58	void Init();
3c1edb34	59	Int_t Write(const char* /x1/ = "",Int_t /x2/ = 0, Int_t /x3/ = 0);
3c1edb34	60	Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return AliHBTMonTwoParticleFctn1D::Write(x1,x2,x3);}
becde6ce	61	void Rename(const Char_t * name);
	62	void Rename(const Char_t * name, const Char_t * title);
	63	TH1* GetResult();
78d7c6d3	64	Double_t GetValue(AliVAODParticle * /track/,AliVAODParticle * /part/) const { return 0.0; }
78d7c6d3	65	void Process(AliVAODParticle * track,AliVAODParticle * part);
becde6ce	66	protected:
2b31c209	67	TH1D* fWrong;//histogram filled with wrongly identified particles
2b31c209	68	TH1D* fAll;//histogram filled with all particles
becde6ce	69	ClassDef(AliHBTMonPIDContaminationVsPtFctn,1)
	70	};
	71	/*************************************************************************************/
	72
61763057	73	class AliHBTQInvCorrelFctnPerfectPID: public AliHBTTwoPairFctn1D, public AliHBTCorrelFunction
	74	{
	75	//Q Invaraint Correlation Function
	76	//1D two particle function
	77	//Fills the function only for correctly reconstructed PID
	78	//Together with
	79	public:
	80	AliHBTQInvCorrelFctnPerfectPID(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
	81	virtual ~AliHBTQInvCorrelFctnPerfectPID(){};
	82	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	83	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	84	TH1* GetResult();
	85	protected:
	86	Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* /partpair/) const {return trackpair->GetQInv();}
	87	private:
	88	ClassDef(AliHBTQInvCorrelFctnPerfectPID,1)
	89	};
	90
	91	/*************************************************************************************/
	92
	93	class AliHBTWeightQInvCorrelFctnPerfectPID: public AliHBTTwoPairFctn1D, public AliHBTCorrelFunction
	94	{
	95	//Weight Q Invaraint Correlation Function
	96	//1D two particle function
	97	//Fills the function only for correctly reconstructed PID
	98	//Together with regular
	99	public:
	100	AliHBTWeightQInvCorrelFctnPerfectPID(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
	101	virtual ~AliHBTWeightQInvCorrelFctnPerfectPID(){};
	102	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	103	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	104	TH1* GetResult();
	105	protected:
	106	Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* /partpair/) const {return trackpair->GetQInv();}
	107	private:
	108	ClassDef(AliHBTWeightQInvCorrelFctnPerfectPID,1)
	109	};
	110	/*************************************************************************************/
	111	class AliHBTWeightQOutSQideQLongFctnPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
	112	{
	113
	114	public:
	115	AliHBTWeightQOutSQideQLongFctnPerfectPID(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
	116	Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
	117	Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
	118	virtual ~AliHBTWeightQOutSQideQLongFctnPerfectPID(){}
	119
	120	TH1* GetResult();
	121	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	122	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	123
	124	protected:
	125	void GetValues(AliHBTPair* /trackpair/, AliHBTPair* /partpair/, Double_t& /x/, Double_t& /y/, Double_t& /z/) const {}
	126
	127	ClassDef(AliHBTWeightQOutSQideQLongFctnPerfectPID,1)
	128	};
	129
	130	/*************************************************************************************/
	131	class AliHBTQOutSQideQLongFctnPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
	132	{
	133
	134	public:
	135	AliHBTQOutSQideQLongFctnPerfectPID(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
	136	Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
137	Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
138	virtual ~AliHBTQOutSQideQLongFctnPerfectPID(){}
139
140	TH1* GetResult();
141	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
142	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
143
144	protected:
145	void GetValues(AliHBTPair* /trackpair/, AliHBTPair* /partpair/, Double_t& /x/, Double_t& /y/, Double_t& /z/) const {}
146
147	ClassDef(AliHBTQOutSQideQLongFctnPerfectPID,1)
148	};
149
150
151	/*************************************************************************************/
152
becde6ce	153	class AliHBTPairPIDProbVsQInvFctn: public AliHBTOnePairFctn1D, public AliHBTCorrelFunction
	154	{
	155	//Q Invaraint Correlation Function
	156	//1D two particle function
	157	public:
	158	AliHBTPairPIDProbVsQInvFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
	159	virtual ~AliHBTPairPIDProbVsQInvFctn(){};
	160	void ProcessSameEventParticles(AliHBTPair* pair);
	161	void ProcessDiffEventParticles(AliHBTPair* pair);
	162	TH1* GetResult();
	163	protected:
a22a56ec	164	Double_t GetValue(AliHBTPair * pair) const {return pair->GetQInv();}
becde6ce	165	private:
	166	ClassDef(AliHBTPairPIDProbVsQInvFctn,1)
	167	};
	168	/*************************************************************************************/
1f4ef2d2	169
becde6ce	170	class AliHBTPairPIDProbVsQOutSQideQLongFctn: public AliHBTOnePairFctn3D, public AliHBTCorrelFunction
	171	{
	172
	173	public:
	174	AliHBTPairPIDProbVsQOutSQideQLongFctn(Int_t nXbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
d277b11c	175	Int_t nYbins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0,
d277b11c	176	Int_t nZbins = 100, Double_t maxZval = 0.15, Double_t minZval = 0.0);
becde6ce	177	virtual ~AliHBTPairPIDProbVsQOutSQideQLongFctn(){}
	178
	179	TH1* GetResult();
	180	void ProcessSameEventParticles(AliHBTPair* part);
	181	void ProcessDiffEventParticles(AliHBTPair* pair);
	182
	183	protected:
a22a56ec	184	void GetValues(AliHBTPair* /pair/, Double_t& /x/, Double_t& /y/, Double_t& /z/) const {}
becde6ce	185
	186	ClassDef(AliHBTPairPIDProbVsQOutSQideQLongFctn,1)
	187	};
1f4ef2d2	188	/******************************************************************/
	189
	190	class AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID: public AliHBTTwoPairFctn3D, public AliHBTCorrelFunction
	191	{
	192	public:
d277b11c	193	AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID(Int_t nXbins = 50, Double_t maxXval = 0.3, Double_t minXval = 0.0,
	194	Int_t nYbins = 50, Double_t maxYval = 0.3, Double_t minYval = 0.0,
	195	Int_t nZbins = 50, Double_t maxZval = 0.3, Double_t minZval = 0.0);
1f4ef2d2	196	virtual ~AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID(){}
	197	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	198	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	199
	200	TH1* GetResult();
	201	protected:
	202	void GetValues(AliHBTPair* /trackpair/, AliHBTPair* /partpair/, Double_t& /x/, Double_t& /y/, Double_t& /z/) const {}
	203	private:
	204	ClassDef(AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID,1)
	205	};
	206	/*************************************************************************************/
	207
	208	class AliHBTPairPIDProbVsPtThetaPhiFctn: public AliHBTOnePairFctn3D, public AliHBTCorrelFunction
	209	{
	210
	211	public:
d277b11c	212	AliHBTPairPIDProbVsPtThetaPhiFctn(Int_t nXbins = 50, Double_t maxXval = 0.3, Double_t minXval = 0.0,
	213	Int_t nYbins = 50, Double_t maxYval = 0.3, Double_t minYval = 0.0,
	214	Int_t nZbins = 50, Double_t maxZval = 0.3, Double_t minZval = 0.0);
1f4ef2d2	215	virtual ~AliHBTPairPIDProbVsPtThetaPhiFctn(){}
	216
	217	TH1* GetResult();
	218	void ProcessSameEventParticles(AliHBTPair* part);
	219	void ProcessDiffEventParticles(AliHBTPair* pair);
	220
	221	protected:
	222	void GetValues(AliHBTPair* /pair/, Double_t& /x/, Double_t& /y/, Double_t& /z/) const {}
	223
	224	ClassDef(AliHBTPairPIDProbVsPtThetaPhiFctn,1)
	225	};
	226
becde6ce	227
	228
	229	#endif