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

#ifndef ALIHBTMONRESOLUTIONFCTNS_H
#define ALIHBTMONRESOLUTIONFCTNS_H
//_______________________________________________________________________________
/////////////////////////////////////////////////////////////////////////////////
//
// class AliHBTMonPxResolutionFctn;
// class AliHBTMonPyResolutionFctn;
// class AliHBTMonPzResolutionFctn;
// class AliHBTMonPResolutionFctn;
// class AliHBTMonPtResolutionFctn;
// class AliHBTMonPhiResolutionFctn;
// class AliHBTMonThetaResolutionFctn;
// class AliHBTMonPxResolutionVsPtFctn;
// class AliHBTMonPyResolutionVsPtFctn;
// class AliHBTMonPzResolutionVsPtFctn;
// class AliHBTMonPResolutionVsPtFctn;
// class AliHBTMonPtResolutionVsPtFctn;
// class AliHBTMonPhiResolutionVsPtFctn;
// class AliHBTMonThetaResolutionVsPtFctn;
//
// Caution: On 2D plots on X axis in simulated values
// That is contrary to two-particle resolutions where it is reconstructed one
//
// added by Zbigniew.Chajecki@cern.ch
// this classes create resolution functions of particle momentum 
//
//////////////////////////////////////////////////////////////////////////////////

class AliHBTMonPxResolutionFctn;
class AliHBTMonPyResolutionFctn;
class AliHBTMonPzResolutionFctn;
class AliHBTMonPResolutionFctn;
class AliHBTMonPtResolutionFctn;
class AliHBTMonPhiResolutionFctn;
class AliHBTMonThetaResolutionFctn;

class AliHBTMonPxResolutionVsPtFctn;
class AliHBTMonPyResolutionVsPtFctn;
class AliHBTMonPzResolutionVsPtFctn;
class AliHBTMonPResolutionVsPtFctn;
class AliHBTMonPtResolutionVsPtFctn;
class AliHBTMonPhiResolutionVsPtFctn;
class AliHBTMonThetaResolutionVsPtFctn;


#include "AliHBTMonitorFunction.h"
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPxResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPxResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPxResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
     { 
        return (partparticle->Px()-trackparticle->Px()) ;
     } 
   ClassDef(AliHBTMonPxResolutionFctn,1)
 };
/***********************************************************************/
class AliHBTMonPyResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPyResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPyResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
     { 
        return (partparticle->Py()-trackparticle->Py()) ;
     } 
   ClassDef(AliHBTMonPyResolutionFctn,1)
 };
/***********************************************************************/
class AliHBTMonPzResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPzResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPzResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle)  const
     { 
        return (partparticle->Pz()-trackparticle->Pz()) ;
     } 
   ClassDef(AliHBTMonPzResolutionFctn,1)
 };
/***********************************************************************/
class AliHBTMonPResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle)  const
     { 
        return (partparticle->P()-trackparticle->P()) ;
     } 
   ClassDef(AliHBTMonPResolutionFctn,1)
 };
/***********************************************************************/
class AliHBTMonPtResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPtResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPtResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle)  const
     { 
        return (partparticle->Pt()-trackparticle->Pt()) ;
     } 
   ClassDef(AliHBTMonPtResolutionFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPxResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPxResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPxResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Px()-trackparticle->Px();
    }
   ClassDef(AliHBTMonPxResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPyResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPyResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPyResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Py()-trackparticle->Py();
    }
   ClassDef(AliHBTMonPyResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPzResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPzResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPzResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Pz()-trackparticle->Pz();
    }
   ClassDef(AliHBTMonPzResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->P()-trackparticle->P();
    }
  protected:
  private:
    ClassDef(AliHBTMonPResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPtResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPtResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPtResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Pt()-trackparticle->Pt();
    }
   ClassDef(AliHBTMonPtResolutionVsPtFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPhiResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonPhiResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonPhiResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle)  const
     { 
        return (partparticle->Phi()-trackparticle->Phi()) ;
     } 
   ClassDef(AliHBTMonPhiResolutionFctn,1)
 };
/***********************************************************************/
class AliHBTMonThetaResolutionFctn: public AliHBTMonTwoParticleFctn1D
 {
  public: 
   AliHBTMonThetaResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
   virtual ~AliHBTMonThetaResolutionFctn(){}

   Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
     { 
        return (partparticle->Theta()-trackparticle->Theta()) ;
     } 
   ClassDef(AliHBTMonThetaResolutionFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPhiResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPhiResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPhiResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Phi()-trackparticle->Phi();
    }
   ClassDef(AliHBTMonPhiResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPhiResolutionVsPhiFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPhiResolutionVsPhiFctn(Int_t nXbins = 200, Double_t maxXval = TMath::TwoPi(), Double_t minXval = 0.0,
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPhiResolutionVsPhiFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Phi();
     y = partparticle->Phi()-trackparticle->Phi();
    }
   ClassDef(AliHBTMonPhiResolutionVsPhiFctn,1)
 };
/***********************************************************************/
class AliHBTMonThetaResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonThetaResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonThetaResolutionVsPtFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Theta()-trackparticle->Theta();
    }
   ClassDef(AliHBTMonThetaResolutionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonThetaResolutionVsThetaFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonThetaResolutionVsThetaFctn(Int_t nXbins = 200, Double_t maxXval = TMath::PiOver2(), Double_t minXval = -TMath::PiOver2(),
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonThetaResolutionVsThetaFctn(){}
   void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
    {
     y = partparticle->Theta()-trackparticle->Theta();
     x = partparticle->Theta();
    }
   ClassDef(AliHBTMonThetaResolutionVsThetaFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/

#endif
Commit	Line	Data
	1	#ifndef ALIHBTMONRESOLUTIONFCTNS_H
	2	#define ALIHBTMONRESOLUTIONFCTNS_H
	3	//_______________________________________________________________________________
	4	/////////////////////////////////////////////////////////////////////////////////
	5	//
	6	// class AliHBTMonPxResolutionFctn;
	7	// class AliHBTMonPyResolutionFctn;
	8	// class AliHBTMonPzResolutionFctn;
	9	// class AliHBTMonPResolutionFctn;
	10	// class AliHBTMonPtResolutionFctn;
	11	// class AliHBTMonPhiResolutionFctn;
	12	// class AliHBTMonThetaResolutionFctn;
	13	// class AliHBTMonPxResolutionVsPtFctn;
	14	// class AliHBTMonPyResolutionVsPtFctn;
	15	// class AliHBTMonPzResolutionVsPtFctn;
	16	// class AliHBTMonPResolutionVsPtFctn;
	17	// class AliHBTMonPtResolutionVsPtFctn;
	18	// class AliHBTMonPhiResolutionVsPtFctn;
	19	// class AliHBTMonThetaResolutionVsPtFctn;
	20	//
	21	// Caution: On 2D plots on X axis in simulated values
	22	// That is contrary to two-particle resolutions where it is reconstructed one
	23	//
	24	// added by Zbigniew.Chajecki@cern.ch
	25	// this classes create resolution functions of particle momentum
	26	//
	27	//////////////////////////////////////////////////////////////////////////////////
	28
	29	class AliHBTMonPxResolutionFctn;
	30	class AliHBTMonPyResolutionFctn;
	31	class AliHBTMonPzResolutionFctn;
	32	class AliHBTMonPResolutionFctn;
	33	class AliHBTMonPtResolutionFctn;
	34	class AliHBTMonPhiResolutionFctn;
	35	class AliHBTMonThetaResolutionFctn;
	36
	37	class AliHBTMonPxResolutionVsPtFctn;
	38	class AliHBTMonPyResolutionVsPtFctn;
	39	class AliHBTMonPzResolutionVsPtFctn;
	40	class AliHBTMonPResolutionVsPtFctn;
	41	class AliHBTMonPtResolutionVsPtFctn;
	42	class AliHBTMonPhiResolutionVsPtFctn;
	43	class AliHBTMonThetaResolutionVsPtFctn;
	44
	45
	46	#include "AliHBTMonitorFunction.h"
	47	/***********************************************************************/
	48	/***********************************************************************/
	49	/***********************************************************************/
	50	class AliHBTMonPxResolutionFctn: public AliHBTMonTwoParticleFctn1D
	51	{
	52	public:
	53	AliHBTMonPxResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	54	virtual ~AliHBTMonPxResolutionFctn(){}
	55
	56	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	57	{
	58	return (partparticle->Px()-trackparticle->Px()) ;
	59	}
	60	ClassDef(AliHBTMonPxResolutionFctn,1)
	61	};
	62	/***********************************************************************/
	63	class AliHBTMonPyResolutionFctn: public AliHBTMonTwoParticleFctn1D
	64	{
	65	public:
	66	AliHBTMonPyResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	67	virtual ~AliHBTMonPyResolutionFctn(){}
	68
	69	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	70	{
	71	return (partparticle->Py()-trackparticle->Py()) ;
	72	}
	73	ClassDef(AliHBTMonPyResolutionFctn,1)
	74	};
	75	/***********************************************************************/
	76	class AliHBTMonPzResolutionFctn: public AliHBTMonTwoParticleFctn1D
	77	{
	78	public:
	79	AliHBTMonPzResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	80	virtual ~AliHBTMonPzResolutionFctn(){}
	81
	82	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	83	{
	84	return (partparticle->Pz()-trackparticle->Pz()) ;
	85	}
	86	ClassDef(AliHBTMonPzResolutionFctn,1)
	87	};
	88	/***********************************************************************/
	89	class AliHBTMonPResolutionFctn: public AliHBTMonTwoParticleFctn1D
	90	{
	91	public:
	92	AliHBTMonPResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	93	virtual ~AliHBTMonPResolutionFctn(){}
	94
	95	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	96	{
	97	return (partparticle->P()-trackparticle->P()) ;
	98	}
	99	ClassDef(AliHBTMonPResolutionFctn,1)
	100	};
	101	/***********************************************************************/
	102	class AliHBTMonPtResolutionFctn: public AliHBTMonTwoParticleFctn1D
	103	{
	104	public:
	105	AliHBTMonPtResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	106	virtual ~AliHBTMonPtResolutionFctn(){}
	107
	108	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	109	{
	110	return (partparticle->Pt()-trackparticle->Pt()) ;
	111	}
	112	ClassDef(AliHBTMonPtResolutionFctn,1)
	113	};
	114	/***********************************************************************/
	115	/***********************************************************************/
	116	/***********************************************************************/
	117	class AliHBTMonPxResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	118	{
	119	public:
	120	AliHBTMonPxResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	121	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	122	virtual ~AliHBTMonPxResolutionVsPtFctn(){}
	123	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	124	{
	125	x = partparticle->Pt();
	126	y = partparticle->Px()-trackparticle->Px();
	127	}
	128	ClassDef(AliHBTMonPxResolutionVsPtFctn,1)
	129	};
	130	/***********************************************************************/
	131	class AliHBTMonPyResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	132	{
	133	public:
	134	AliHBTMonPyResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	135	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	136	virtual ~AliHBTMonPyResolutionVsPtFctn(){}
	137	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	138	{
	139	x = partparticle->Pt();
	140	y = partparticle->Py()-trackparticle->Py();
	141	}
	142	ClassDef(AliHBTMonPyResolutionVsPtFctn,1)
	143	};
	144	/***********************************************************************/
	145	class AliHBTMonPzResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	146	{
	147	public:
	148	AliHBTMonPzResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	149	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	150	virtual ~AliHBTMonPzResolutionVsPtFctn(){}
	151	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	152	{
	153	x = partparticle->Pt();
	154	y = partparticle->Pz()-trackparticle->Pz();
	155	}
	156	ClassDef(AliHBTMonPzResolutionVsPtFctn,1)
	157	};
	158	/***********************************************************************/
	159	class AliHBTMonPResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	160	{
	161	public:
	162	AliHBTMonPResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	163	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	164	virtual ~AliHBTMonPResolutionVsPtFctn(){}
	165	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	166	{
	167	x = partparticle->Pt();
	168	y = partparticle->P()-trackparticle->P();
	169	}
	170	protected:
	171	private:
	172	ClassDef(AliHBTMonPResolutionVsPtFctn,1)
	173	};
	174	/***********************************************************************/
	175	class AliHBTMonPtResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	176	{
	177	public:
	178	AliHBTMonPtResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	179	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	180	virtual ~AliHBTMonPtResolutionVsPtFctn(){}
	181	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	182	{
	183	x = partparticle->Pt();
	184	y = partparticle->Pt()-trackparticle->Pt();
	185	}
	186	ClassDef(AliHBTMonPtResolutionVsPtFctn,1)
	187	};
	188	/***********************************************************************/
	189	/***********************************************************************/
	190	/***********************************************************************/
	191	/***********************************************************************/
	192	class AliHBTMonPhiResolutionFctn: public AliHBTMonTwoParticleFctn1D
	193	{
	194	public:
	195	AliHBTMonPhiResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	196	virtual ~AliHBTMonPhiResolutionFctn(){}
	197
	198	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	199	{
	200	return (partparticle->Phi()-trackparticle->Phi()) ;
	201	}
	202	ClassDef(AliHBTMonPhiResolutionFctn,1)
	203	};
	204	/***********************************************************************/
	205	class AliHBTMonThetaResolutionFctn: public AliHBTMonTwoParticleFctn1D
	206	{
	207	public:
	208	AliHBTMonThetaResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
	209	virtual ~AliHBTMonThetaResolutionFctn(){}
	210
	211	Double_t GetValue(AliVAODParticle * trackparticle,AliVAODParticle * partparticle) const
	212	{
	213	return (partparticle->Theta()-trackparticle->Theta()) ;
	214	}
	215	ClassDef(AliHBTMonThetaResolutionFctn,1)
	216	};
	217	/***********************************************************************/
	218	/***********************************************************************/
	219	class AliHBTMonPhiResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	220	{
	221	public:
	222	AliHBTMonPhiResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0,
	223	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	224	virtual ~AliHBTMonPhiResolutionVsPtFctn(){}
	225	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	226	{
	227	x = partparticle->Pt();
	228	y = partparticle->Phi()-trackparticle->Phi();
	229	}
	230	ClassDef(AliHBTMonPhiResolutionVsPtFctn,1)
	231	};
	232	/***********************************************************************/
	233	class AliHBTMonPhiResolutionVsPhiFctn: public AliHBTMonTwoParticleFctn2D
	234	{
	235	public:
	236	AliHBTMonPhiResolutionVsPhiFctn(Int_t nXbins = 200, Double_t maxXval = TMath::TwoPi(), Double_t minXval = 0.0,
	237	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	238	virtual ~AliHBTMonPhiResolutionVsPhiFctn(){}
	239	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	240	{
	241	x = partparticle->Phi();
	242	y = partparticle->Phi()-trackparticle->Phi();
	243	}
	244	ClassDef(AliHBTMonPhiResolutionVsPhiFctn,1)
	245	};
	246	/***********************************************************************/
	247	class AliHBTMonThetaResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
	248	{
	249	public:
	250	AliHBTMonThetaResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	251	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	252	virtual ~AliHBTMonThetaResolutionVsPtFctn(){}
	253	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	254	{
	255	x = partparticle->Pt();
	256	y = partparticle->Theta()-trackparticle->Theta();
	257	}
	258	ClassDef(AliHBTMonThetaResolutionVsPtFctn,1)
	259	};
	260
	261	/***********************************************************************/
	262	class AliHBTMonThetaResolutionVsThetaFctn: public AliHBTMonTwoParticleFctn2D
	263	{
	264	public:
	265	AliHBTMonThetaResolutionVsThetaFctn(Int_t nXbins = 200, Double_t maxXval = TMath::PiOver2(), Double_t minXval = -TMath::PiOver2(),
	266	Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
	267	virtual ~AliHBTMonThetaResolutionVsThetaFctn(){}
	268	void GetValues(AliVAODParticle* trackparticle, AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	269	{
	270	y = partparticle->Theta()-trackparticle->Theta();
	271	x = partparticle->Theta();
	272	}
	273	ClassDef(AliHBTMonThetaResolutionVsThetaFctn,1)
	274	};
	275	/***********************************************************************/
	276	/***********************************************************************/
	277	/***********************************************************************/
	278	/***********************************************************************/
	279	/***********************************************************************/
	280	/***********************************************************************/
	281	/***********************************************************************/
	282	/***********************************************************************/
	283	/***********************************************************************/
	284	/***********************************************************************/
	285
	286	#endif