[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(){};
   TH1* GetResult(){return fResult;}
 protected:
   Double_t GetValue(AliHBTParticle * particle) { return particle->Px();}
   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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
      x = partparticle->Pt();
      y = partparticle->Px();
    }
   TH1* GetResult(){return fResult;} 
   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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->Py();
    }
  TH1* GetResult(){return fResult;} 
  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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->Pz();
    }
   TH1* GetResult(){return fResult;} 
   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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->P();
    }
   TH1* GetResult(){return fResult;} 
   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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;} 
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->Phi();
    }
  TH1* GetResult(){return fResult;}
  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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
      x = partparticle->Pt();
      y = partparticle->Theta();
    }
   TH1* GetResult(){return fResult;} 
   ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
 };

/***********************************************************************/
class AliHBTMonVxDistributionFctn: public AliHBTMonOneParticleFctn1D
{
 public:
   AliHBTMonVxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
   virtual ~AliHBTMonVxDistributionFctn(){};
   TH1* GetResult(){return fResult;}
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;}
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;}
 protected:
   Double_t GetValue(AliHBTParticle * particle) { 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(){};
   TH1* GetResult(){return fResult;}
 protected:
   Double_t GetValue(AliHBTParticle * p) { 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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
      x = partparticle->Vx();
      y = partparticle->Vy();
    }
   TH1* GetResult(){return fResult;} 
   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(AliHBTParticle* partparticle,  Double_t& x, Double_t& y)
    {
      x = partparticle->Vz();
      y = TMath::Hypot(partparticle->Vx(),partparticle->Vy());
    }
   TH1* GetResult(){return fResult;}
   ClassDef(AliHBTMonRtDistributionVsVzFctn,1)
 };

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

#endif
Commit	Line	Data
58ee8590	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	//
a57afe91	22	// added by Zbigniew.Chajecki@cern.ch
58ee8590	23	// this classes create distribution functions of particle momentum
	24	//
	25	/////////////////////////////////////////////////////////////////
a57afe91	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
88cb7938	37	class AliHBTMonVxDistributionFctn;
	38	class AliHBTMonVyDistributionFctn;
	39	class AliHBTMonVzDistributionFctn;
	40	class AliHBTMonRDistributionFctn;
	41
	42	class AliHBTMonVyDistributionVsVxFctn;
	43	class AliHBTMonRtDistributionVsVzFctn;
	44
a57afe91	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	TH1* GetResult(){return fResult;}
	56	protected:
	57	Double_t GetValue(AliHBTParticle * particle) { return particle->Px();}
58ee8590	58	ClassDef(AliHBTMonPxDistributionFctn,1)
a57afe91	59	};
	60	/*************************************************************************************/
	61
	62	class AliHBTMonPyDistributionFctn: public AliHBTMonOneParticleFctn1D
	63	{
	64	public:
	65	AliHBTMonPyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	66	virtual ~AliHBTMonPyDistributionFctn(){};
	67	TH1* GetResult(){return fResult;}
	68	protected:
	69	Double_t GetValue(AliHBTParticle * particle) { return particle->Py();}
58ee8590	70	ClassDef(AliHBTMonPyDistributionFctn,1)
a57afe91	71	};
	72	/*************************************************************************************/
	73
	74	class AliHBTMonPzDistributionFctn: public AliHBTMonOneParticleFctn1D
	75	{
	76	public:
	77	AliHBTMonPzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	78	virtual ~AliHBTMonPzDistributionFctn(){};
	79	TH1* GetResult(){return fResult;}
	80	protected:
	81	Double_t GetValue(AliHBTParticle * particle) { return particle->Pz();}
58ee8590	82	ClassDef(AliHBTMonPzDistributionFctn,1)
a57afe91	83
	84	};
	85	/*************************************************************************************/
	86
	87	class AliHBTMonPDistributionFctn: public AliHBTMonOneParticleFctn1D
	88	{
	89	public:
	90	AliHBTMonPDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
	91	virtual ~AliHBTMonPDistributionFctn(){};
	92	TH1* GetResult(){return fResult;}
	93	protected:
	94	Double_t GetValue(AliHBTParticle * particle) { return particle->P();}
58ee8590	95	ClassDef(AliHBTMonPDistributionFctn,1)
a57afe91	96
	97	};
	98	/*************************************************************************************/
	99
	100	class AliHBTMonPtDistributionFctn: public AliHBTMonOneParticleFctn1D
	101	{
	102	public:
	103	AliHBTMonPtDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
	104	virtual ~AliHBTMonPtDistributionFctn(){};
	105	TH1* GetResult(){return fResult;}
	106	protected:
	107	Double_t GetValue(AliHBTParticle * particle) { return particle->Pt();}
58ee8590	108	ClassDef(AliHBTMonPtDistributionFctn,1)
a57afe91	109	};
	110
	111	/***********************************************************************/
	112	class AliHBTMonPxDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	113	{
	114	public:
	115	AliHBTMonPxDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	116	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	117	virtual ~AliHBTMonPxDistributionVsPtFctn(){}
	118
	119	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	120	{
58ee8590	121	x = partparticle->Pt();
58ee8590	122	y = partparticle->Px();
a57afe91	123	}
a57afe91	124	TH1* GetResult(){return fResult;}
58ee8590	125	ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
a57afe91	126	};
	127
	128	/***********************************************************************/
	129	class AliHBTMonPyDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	130	{
	131	public:
	132	AliHBTMonPyDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	133	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	134	virtual ~AliHBTMonPyDistributionVsPtFctn(){}
	135
	136	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	137	{
	138	x = partparticle->Pt();
	139	y = partparticle->Py();
	140	}
58ee8590	141	TH1* GetResult(){return fResult;}
58ee8590	142	ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
a57afe91	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(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	153	{
	154	x = partparticle->Pt();
	155	y = partparticle->Pz();
	156	}
	157	TH1* GetResult(){return fResult;}
58ee8590	158	ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
a57afe91	159	};
	160
	161	/***********************************************************************/
	162	class AliHBTMonPDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	163	{
	164	public:
	165	AliHBTMonPDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	166	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
	167	virtual ~AliHBTMonPDistributionVsPtFctn(){}
	168
	169	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	170	{
	171	x = partparticle->Pt();
	172	y = partparticle->P();
	173	}
	174	TH1* GetResult(){return fResult;}
58ee8590	175	ClassDef(AliHBTMonPDistributionVsPtFctn,1)
a57afe91	176	};
	177
	178	/***********************************************************************/
	179	/***********************************************************************/
	180	/***********************************************************************/
	181	/***********************************************************************/
	182
	183	class AliHBTMonPhiDistributionFctn: public AliHBTMonOneParticleFctn1D
	184	{
	185	public:
	186	AliHBTMonPhiDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
	187	virtual ~AliHBTMonPhiDistributionFctn(){};
	188	TH1* GetResult(){return fResult;}
	189	protected:
	190	Double_t GetValue(AliHBTParticle * particle) { return particle->Phi();}
58ee8590	191	ClassDef(AliHBTMonPhiDistributionFctn,1)
a57afe91	192	};
	193
	194	/***********************************************************************/
	195	class AliHBTMonThetaDistributionFctn: public AliHBTMonOneParticleFctn1D
	196	{
	197	public:
	198	AliHBTMonThetaDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
	199	virtual ~AliHBTMonThetaDistributionFctn(){};
	200	TH1* GetResult(){return fResult;}
	201	protected:
	202	Double_t GetValue(AliHBTParticle * particle) { return particle->Theta();}
58ee8590	203	ClassDef(AliHBTMonThetaDistributionFctn,1)
a57afe91	204
	205	};
	206	/***********************************************************************/
	207	/***********************************************************************/
	208	class AliHBTMonPhiDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
	209	{
	210	public:
	211	AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	212	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
	213	virtual ~AliHBTMonPhiDistributionVsPtFctn(){}
	214
	215	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	216	{
	217	x = partparticle->Pt();
	218	y = partparticle->Phi();
	219	}
58ee8590	220	TH1* GetResult(){return fResult;}
58ee8590	221	ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
a57afe91	222	};
	223
	224	/***********************************************************************/
	225	class AliHBTMonThetaDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
88cb7938	226	{
a57afe91	227	public:
	228	AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
	229	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
	230	virtual ~AliHBTMonThetaDistributionVsPtFctn(){}
	231
	232	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	233	{
	234	x = partparticle->Pt();
	235	y = partparticle->Theta();
	236	}
	237	TH1* GetResult(){return fResult;}
a57afe91	238	ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
	239	};
	240
	241	/***********************************************************************/
88cb7938	242	class AliHBTMonVxDistributionFctn: public AliHBTMonOneParticleFctn1D
	243	{
	244	public:
	245	AliHBTMonVxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	246	virtual ~AliHBTMonVxDistributionFctn(){};
	247	TH1* GetResult(){return fResult;}
	248	protected:
	249	Double_t GetValue(AliHBTParticle * particle) { return particle->Vx();}
	250	ClassDef(AliHBTMonVxDistributionFctn,1)
	251	};
a57afe91	252	/***********************************************************************/
88cb7938	253	class AliHBTMonVyDistributionFctn: public AliHBTMonOneParticleFctn1D
	254	{
	255	public:
	256	AliHBTMonVyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	257	virtual ~AliHBTMonVyDistributionFctn(){};
	258	TH1* GetResult(){return fResult;}
	259	protected:
	260	Double_t GetValue(AliHBTParticle * particle) { return particle->Vy();}
	261	ClassDef(AliHBTMonVyDistributionFctn,1)
	262	};
	263	/***********************************************************************/
	264	class AliHBTMonVzDistributionFctn: public AliHBTMonOneParticleFctn1D
	265	{
	266	public:
	267	AliHBTMonVzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 300, Double_t minXval = -300);
	268	virtual ~AliHBTMonVzDistributionFctn(){};
	269	TH1* GetResult(){return fResult;}
	270	protected:
	271	Double_t GetValue(AliHBTParticle * particle) { return particle->Vz();}
	272	ClassDef(AliHBTMonVzDistributionFctn,1)
	273	};
	274	/***********************************************************************/
	275	class AliHBTMonRDistributionFctn: public AliHBTMonOneParticleFctn1D
	276	{
	277	public:
	278	AliHBTMonRDistributionFctn(Int_t nbins = 200, Double_t maxXval = 500, Double_t minXval = -500);
	279	virtual ~AliHBTMonRDistributionFctn(){};
	280	TH1* GetResult(){return fResult;}
	281	protected:
	282	Double_t GetValue(AliHBTParticle * p) { return TMath::Sqrt(p->Vx()p->Vx() + p->Vy()p->Vy() + p->Vz()*p->Vz());}
	283	ClassDef(AliHBTMonRDistributionFctn,1)
	284	};
	285
	286	/***********************************************************************/
	287	class AliHBTMonVyDistributionVsVxFctn: public AliHBTMonOneParticleFctn2D
	288	{
	289	public:
	290	AliHBTMonVyDistributionVsVxFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0,
	291	Int_t nYbins = 200, Double_t maxYval = 10.0, Double_t minYval =-10.0);
	292	virtual ~AliHBTMonVyDistributionVsVxFctn(){}
	293
	294	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	295	{
	296	x = partparticle->Vx();
	297	y = partparticle->Vy();
	298	}
	299	TH1* GetResult(){return fResult;}
88cb7938	300	ClassDef(AliHBTMonVyDistributionVsVxFctn,1)
	301	};
	302
	303
	304	class AliHBTMonRtDistributionVsVzFctn: public AliHBTMonOneParticleFctn2D
	305	{
	306	public:
	307	AliHBTMonRtDistributionVsVzFctn(Int_t nXbins = 200, Double_t maxXval = 10.0, Double_t minXval = -10.0,
	308	Int_t nYbins = 100, Double_t maxYval = 10.0, Double_t minYval = 0.0);
	309	virtual ~AliHBTMonRtDistributionVsVzFctn(){}
	310
	311	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
	312	{
	313	x = partparticle->Vz();
	314	y = TMath::Hypot(partparticle->Vx(),partparticle->Vy());
	315	}
	316	TH1* GetResult(){return fResult;}
88cb7938	317	ClassDef(AliHBTMonRtDistributionVsVzFctn,1)
	318	};
	319
a57afe91	320	/***********************************************************************/
a57afe91	321	/***********************************************************************/
a57afe91	322
a57afe91	323	#endif