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

#ifndef ALIHBTMONDISTRIBUTIONFCTNS_H
#define ALIHBTMONDISTRIBUTIONFCTNS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

//______________________________________________________________
////////////////////////////////////////////////////////////////
//
// 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 <TMath.h>

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