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

#ifndef ALIHBTMONDISTRIBUTIONFCTNS_H
#define ALIHBTMONDISTRIBUTIONFCTNS_H
//______________________________________________________________
////////////////////////////////////////////////////////////////
//
// class AliHBTMonPxDistributionFctn;
// class AliHBTMonPxDistributionVsPtFctn;
// class AliHBTMonPyDistributionFctn;
// class AliHBTMonPyDistributionVsPtFctn;
// class AliHBTMonPzDistributionFctn;
// class AliHBTMonPzDistributionVsPtFctn;
// class AliHBTMonPDistributionFctn;
// class AliHBTMonPDistributionVsPtFctn;
// class AliHBTMonPtDistributionFctn;
// class AliHBTMonVxDistributionFctn;
// class AliHBTMonVyDistributionFctn;
// class AliHBTMonVzDistributionFctn;
// class AliHBTMonRDistributionFctn;
// class AliHBTMonVyDistributionVsVxFctn;
// class AliHBTMonRtDistributionVsVzFctn;
//
// added by Zbigniew.Chajecki@cern.ch
// this classes create distribution functions of particle momentum
//
/////////////////////////////////////////////////////////////////

class AliHBTMonPxDistributionFctn;
class AliHBTMonPxDistributionVsPtFctn;
class AliHBTMonPyDistributionFctn;
class AliHBTMonPyDistributionVsPtFctn;
class AliHBTMonPzDistributionFctn;
class AliHBTMonPzDistributionVsPtFctn;
class AliHBTMonPDistributionFctn;
class AliHBTMonPDistributionVsPtFctn;
class AliHBTMonPtDistributionFctn;

class AliHBTMonVxDistributionFctn;
class AliHBTMonVyDistributionFctn;
class AliHBTMonVzDistributionFctn;
class AliHBTMonRDistributionFctn;

class AliHBTMonVyDistributionVsVxFctn;
class AliHBTMonRtDistributionVsVzFctn;

#include "AliHBTMonitorFunction.h"
/***********************************************************************/
/***********************************************************************/
/*************************************************************************************/ 

class AliHBTMonPxDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
   virtual ~AliHBTMonPxDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const;
   ClassDef(AliHBTMonPxDistributionFctn,1)
};
/*************************************************************************************/ 

class AliHBTMonPyDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
   virtual ~AliHBTMonPyDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Py();}
   ClassDef(AliHBTMonPyDistributionFctn,1)
};
/*************************************************************************************/ 

class AliHBTMonPzDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
   virtual ~AliHBTMonPzDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Pz();}
   ClassDef(AliHBTMonPzDistributionFctn,1)
 
};
/*************************************************************************************/ 

class AliHBTMonPDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
   virtual ~AliHBTMonPDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->P();}
   ClassDef(AliHBTMonPDistributionFctn,1)
 
};
/*************************************************************************************/ 

class AliHBTMonPtDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPtDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
   virtual ~AliHBTMonPtDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Pt();}
   ClassDef(AliHBTMonPtDistributionFctn,1)
};

/***********************************************************************/
class AliHBTMonPxDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
 {
  public: 
   AliHBTMonPxDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
   virtual ~AliHBTMonPxDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
      x = partparticle->Pt();
      y = partparticle->Px();
    }
   ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonPyDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
 {
  public: 
   AliHBTMonPyDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
   virtual ~AliHBTMonPyDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Py();
    }
  ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonPzDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
 {
  public: 
   AliHBTMonPzDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
   virtual ~AliHBTMonPzDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Pz();
    }
   ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonPDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
 {
  public: 
   AliHBTMonPDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
   virtual ~AliHBTMonPDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->P();
    }
   ClassDef(AliHBTMonPDistributionVsPtFctn,1)
 };

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

class AliHBTMonPhiDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonPhiDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
   virtual ~AliHBTMonPhiDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Phi();}
   ClassDef(AliHBTMonPhiDistributionFctn,1)
};

/***********************************************************************/
class AliHBTMonThetaDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonThetaDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
   virtual ~AliHBTMonThetaDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Theta();}
   ClassDef(AliHBTMonThetaDistributionFctn,1)
 
};
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPhiDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
 {
  public: 
   AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
   virtual ~AliHBTMonPhiDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
     x = partparticle->Pt();
     y = partparticle->Phi();
    }
  ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonThetaDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
{
  public: 
   AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
   virtual ~AliHBTMonThetaDistributionVsPtFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
      x = partparticle->Pt();
      y = partparticle->Theta();
    }
   ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonVxDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonVxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
   virtual ~AliHBTMonVxDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle)  const{ return particle->Vx();}
   ClassDef(AliHBTMonVxDistributionFctn,1)
};
/***********************************************************************/
class AliHBTMonVyDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonVyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
   virtual ~AliHBTMonVyDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Vy();}
   ClassDef(AliHBTMonVyDistributionFctn,1)
};
/***********************************************************************/
class AliHBTMonVzDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonVzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 300, Double_t minXval = -300);
   virtual ~AliHBTMonVzDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * particle) const { return particle->Vz();}
   ClassDef(AliHBTMonVzDistributionFctn,1)
};
/***********************************************************************/
class AliHBTMonRDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonRDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
   virtual ~AliHBTMonRDistributionFctn(){};
 protected:
   Double_t GetValue(AliVAODParticle * p) const { return TMath::Sqrt(p->Vx()*p->Vx() + p->Vy()*p->Vy() + p->Vz()*p->Vz());}
   ClassDef(AliHBTMonRDistributionFctn,1)
};

/***********************************************************************/
class AliHBTMonVyDistributionVsVxFctn: public AliHBTMonOneParticleFctn2D
{
  public: 
   AliHBTMonVyDistributionVsVxFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0, 
                                   Int_t nYbins = 200, Double_t maxYval = 10.0, Double_t minYval =-10.0);
   virtual ~AliHBTMonVyDistributionVsVxFctn(){}

   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
      x = partparticle->Vx();
      y = partparticle->Vy();
    }
   ClassDef(AliHBTMonVyDistributionVsVxFctn,1)
 };


class AliHBTMonRtDistributionVsVzFctn: public AliHBTMonOneParticleFctn2D
{
  public: 
   AliHBTMonRtDistributionVsVzFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0, 
                                   Int_t nYbins = 100, Double_t maxYval = 10.0, Double_t minYval = 0.0);
   virtual ~AliHBTMonRtDistributionVsVzFctn(){}
 
   void GetValues(AliVAODParticle* partparticle,  Double_t& x, Double_t& y) const
    {
      x = partparticle->Vz();
      y = TMath::Hypot(partparticle->Vx(),partparticle->Vy());
    }
   ClassDef(AliHBTMonRtDistributionVsVzFctn,1)
 };

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

#endif
Commit	Line	Data
	1	#ifndef ALIHBTMONDISTRIBUTIONFCTNS_H
	2	#define ALIHBTMONDISTRIBUTIONFCTNS_H
	3	//______________________________________________________________
	4	////////////////////////////////////////////////////////////////
	5	//
	6	// class AliHBTMonPxDistributionFctn;
	7	// class AliHBTMonPxDistributionVsPtFctn;
	8	// class AliHBTMonPyDistributionFctn;
	9	// class AliHBTMonPyDistributionVsPtFctn;
	10	// class AliHBTMonPzDistributionFctn;
	11	// class AliHBTMonPzDistributionVsPtFctn;
	12	// class AliHBTMonPDistributionFctn;
	13	// class AliHBTMonPDistributionVsPtFctn;
	14	// class AliHBTMonPtDistributionFctn;
	15	// class AliHBTMonVxDistributionFctn;
	16	// class AliHBTMonVyDistributionFctn;
	17	// class AliHBTMonVzDistributionFctn;
	18	// class AliHBTMonRDistributionFctn;
	19	// class AliHBTMonVyDistributionVsVxFctn;
	20	// class AliHBTMonRtDistributionVsVzFctn;
	21	//
	22	// added by Zbigniew.Chajecki@cern.ch
	23	// this classes create distribution functions of particle momentum
	24	//
	25	/////////////////////////////////////////////////////////////////
	26
	27	class AliHBTMonPxDistributionFctn;
	28	class AliHBTMonPxDistributionVsPtFctn;
	29	class AliHBTMonPyDistributionFctn;
	30	class AliHBTMonPyDistributionVsPtFctn;
	31	class AliHBTMonPzDistributionFctn;
	32	class AliHBTMonPzDistributionVsPtFctn;
	33	class AliHBTMonPDistributionFctn;
	34	class AliHBTMonPDistributionVsPtFctn;
	35	class AliHBTMonPtDistributionFctn;
	36
	37	class AliHBTMonVxDistributionFctn;
	38	class AliHBTMonVyDistributionFctn;
	39	class AliHBTMonVzDistributionFctn;
	40	class AliHBTMonRDistributionFctn;
	41
	42	class AliHBTMonVyDistributionVsVxFctn;
	43	class AliHBTMonRtDistributionVsVzFctn;
	44
	45	#include "AliHBTMonitorFunction.h"
	46	/***********************************************************************/
	47	/***********************************************************************/
	48	/*************************************************************************************/
	49
	50	class AliHBTMonPxDistributionFctn: public AliHBTMonOneParticleFctn1D
	51	{
	52	public:
	53	AliHBTMonPxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	54	virtual ~AliHBTMonPxDistributionFctn(){};
	55	protected:
	56	Double_t GetValue(AliVAODParticle * particle) const;
	57	ClassDef(AliHBTMonPxDistributionFctn,1)
	58	};
	59	/*************************************************************************************/
	60
	61	class AliHBTMonPyDistributionFctn: public AliHBTMonOneParticleFctn1D
	62	{
	63	public:
	64	AliHBTMonPyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	65	virtual ~AliHBTMonPyDistributionFctn(){};
	66	protected:
	67	Double_t GetValue(AliVAODParticle * particle) const { return particle->Py();}
	68	ClassDef(AliHBTMonPyDistributionFctn,1)
	69	};
	70	/*************************************************************************************/
	71
	72	class AliHBTMonPzDistributionFctn: public AliHBTMonOneParticleFctn1D
	73	{
	74	public:
	75	AliHBTMonPzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	76	virtual ~AliHBTMonPzDistributionFctn(){};
	77	protected:
	78	Double_t GetValue(AliVAODParticle * particle) const { return particle->Pz();}
	79	ClassDef(AliHBTMonPzDistributionFctn,1)
	80
	81	};
	82	/*************************************************************************************/
	83
	84	class AliHBTMonPDistributionFctn: public AliHBTMonOneParticleFctn1D
	85	{
	86	public:
	87	AliHBTMonPDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
	88	virtual ~AliHBTMonPDistributionFctn(){};
	89	protected:
	90	Double_t GetValue(AliVAODParticle * particle) const { return particle->P();}
	91	ClassDef(AliHBTMonPDistributionFctn,1)
	92
	93	};
	94	/*************************************************************************************/
	95
	96	class AliHBTMonPtDistributionFctn: public AliHBTMonOneParticleFctn1D
	97	{
	98	public:
	99	AliHBTMonPtDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
	100	virtual ~AliHBTMonPtDistributionFctn(){};
	101	protected:
	102	Double_t GetValue(AliVAODParticle * particle) const { return particle->Pt();}
	103	ClassDef(AliHBTMonPtDistributionFctn,1)
	104	};
	105
	106	/***********************************************************************/
	107	class AliHBTMonPxDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	108	{
	109	public:
	110	AliHBTMonPxDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	111	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	112	virtual ~AliHBTMonPxDistributionVsPtFctn(){}
	113
	114	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	115	{
	116	x = partparticle->Pt();
	117	y = partparticle->Px();
	118	}
	119	ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
	120	};
	121
	122	/***********************************************************************/
	123	class AliHBTMonPyDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	124	{
	125	public:
	126	AliHBTMonPyDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	127	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	128	virtual ~AliHBTMonPyDistributionVsPtFctn(){}
	129
	130	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	131	{
	132	x = partparticle->Pt();
	133	y = partparticle->Py();
	134	}
	135	ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
	136	};
	137	/***********************************************************************/
	138	class AliHBTMonPzDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	139	{
	140	public:
	141	AliHBTMonPzDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	142	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	143	virtual ~AliHBTMonPzDistributionVsPtFctn(){}
	144
	145	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	146	{
	147	x = partparticle->Pt();
	148	y = partparticle->Pz();
	149	}
	150	ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
	151	};
	152
	153	/***********************************************************************/
	154	class AliHBTMonPDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	155	{
	156	public:
	157	AliHBTMonPDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	158	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	159	virtual ~AliHBTMonPDistributionVsPtFctn(){}
	160
	161	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	162	{
	163	x = partparticle->Pt();
	164	y = partparticle->P();
	165	}
	166	ClassDef(AliHBTMonPDistributionVsPtFctn,1)
	167	};
	168
	169	/***********************************************************************/
	170	/***********************************************************************/
	171	/***********************************************************************/
	172	/***********************************************************************/
	173
	174	class AliHBTMonPhiDistributionFctn: public AliHBTMonOneParticleFctn1D
	175	{
	176	public:
	177	AliHBTMonPhiDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
	178	virtual ~AliHBTMonPhiDistributionFctn(){};
	179	protected:
	180	Double_t GetValue(AliVAODParticle * particle) const { return particle->Phi();}
	181	ClassDef(AliHBTMonPhiDistributionFctn,1)
	182	};
	183
	184	/***********************************************************************/
	185	class AliHBTMonThetaDistributionFctn: public AliHBTMonOneParticleFctn1D
	186	{
	187	public:
	188	AliHBTMonThetaDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
	189	virtual ~AliHBTMonThetaDistributionFctn(){};
	190	protected:
	191	Double_t GetValue(AliVAODParticle * particle) const { return particle->Theta();}
	192	ClassDef(AliHBTMonThetaDistributionFctn,1)
	193
	194	};
	195	/***********************************************************************/
	196	/***********************************************************************/
	197	class AliHBTMonPhiDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	198	{
	199	public:
	200	AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	201	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
	202	virtual ~AliHBTMonPhiDistributionVsPtFctn(){}
	203
	204	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	205	{
	206	x = partparticle->Pt();
	207	y = partparticle->Phi();
	208	}
	209	ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
	210	};
	211
	212	/***********************************************************************/
	213	class AliHBTMonThetaDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	214	{
	215	public:
	216	AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	217	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
	218	virtual ~AliHBTMonThetaDistributionVsPtFctn(){}
	219
	220	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	221	{
	222	x = partparticle->Pt();
	223	y = partparticle->Theta();
	224	}
	225	ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
	226	};
	227
	228	/***********************************************************************/
	229	class AliHBTMonVxDistributionFctn: public AliHBTMonOneParticleFctn1D
	230	{
	231	public:
	232	AliHBTMonVxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	233	virtual ~AliHBTMonVxDistributionFctn(){};
	234	protected:
	235	Double_t GetValue(AliVAODParticle * particle) const{ return particle->Vx();}
	236	ClassDef(AliHBTMonVxDistributionFctn,1)
	237	};
	238	/***********************************************************************/
	239	class AliHBTMonVyDistributionFctn: public AliHBTMonOneParticleFctn1D
	240	{
	241	public:
	242	AliHBTMonVyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	243	virtual ~AliHBTMonVyDistributionFctn(){};
	244	protected:
	245	Double_t GetValue(AliVAODParticle * particle) const { return particle->Vy();}
	246	ClassDef(AliHBTMonVyDistributionFctn,1)
	247	};
	248	/***********************************************************************/
	249	class AliHBTMonVzDistributionFctn: public AliHBTMonOneParticleFctn1D
	250	{
	251	public:
	252	AliHBTMonVzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 300, Double_t minXval = -300);
	253	virtual ~AliHBTMonVzDistributionFctn(){};
	254	protected:
	255	Double_t GetValue(AliVAODParticle * particle) const { return particle->Vz();}
	256	ClassDef(AliHBTMonVzDistributionFctn,1)
	257	};
	258	/***********************************************************************/
	259	class AliHBTMonRDistributionFctn: public AliHBTMonOneParticleFctn1D
	260	{
	261	public:
	262	AliHBTMonRDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	263	virtual ~AliHBTMonRDistributionFctn(){};
	264	protected:
	265	Double_t GetValue(AliVAODParticle * p) const { return TMath::Sqrt(p->Vx()p->Vx() + p->Vy()p->Vy() + p->Vz()*p->Vz());}
	266	ClassDef(AliHBTMonRDistributionFctn,1)
	267	};
	268
	269	/***********************************************************************/
	270	class AliHBTMonVyDistributionVsVxFctn: public AliHBTMonOneParticleFctn2D
	271	{
	272	public:
	273	AliHBTMonVyDistributionVsVxFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0,
	274	Int_t nYbins = 200, Double_t maxYval = 10.0, Double_t minYval =-10.0);
	275	virtual ~AliHBTMonVyDistributionVsVxFctn(){}
	276
	277	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	278	{
	279	x = partparticle->Vx();
	280	y = partparticle->Vy();
	281	}
	282	ClassDef(AliHBTMonVyDistributionVsVxFctn,1)
	283	};
	284
	285
	286	class AliHBTMonRtDistributionVsVzFctn: public AliHBTMonOneParticleFctn2D
	287	{
	288	public:
	289	AliHBTMonRtDistributionVsVzFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0,
	290	Int_t nYbins = 100, Double_t maxYval = 10.0, Double_t minYval = 0.0);
	291	virtual ~AliHBTMonRtDistributionVsVzFctn(){}
	292
	293	void GetValues(AliVAODParticle* partparticle, Double_t& x, Double_t& y) const
	294	{
	295	x = partparticle->Vz();
	296	y = TMath::Hypot(partparticle->Vx(),partparticle->Vy());
	297	}
	298	ClassDef(AliHBTMonRtDistributionVsVzFctn,1)
	299	};
	300
	301	/***********************************************************************/
	302	/***********************************************************************/
	303
	304	#endif