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