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

#ifndef ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
#define ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H

// 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;

#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();}
  public:
    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();}
  public:
    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();}
  public:
    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();}
  public:
    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();}
  public:
    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;} 
  protected:
  private:
  public:
    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;} 
  protected:
  private:
  public:
    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;} 
  protected:
  private:
  public:
    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;} 
  protected:
  private:
  public:
    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();}
  public:
    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();}
  public:
    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;} 
  protected:
  private:
  public:
    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;} 
  protected:
  private:
  public:
   ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
 };

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

#endif
Commit	Line	Data
a57afe91	1	#ifndef ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
	2	#define ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
	3
	4	// added by Zbigniew.Chajecki@cern.ch
	5	// this classes create distribution functions of particle momentum
	6
	7	class AliHBTMonPxDistributionFctn;
	8	class AliHBTMonPxDistributionVsPtFctn;
	9	class AliHBTMonPyDistributionFctn;
	10	class AliHBTMonPyDistributionVsPtFctn;
	11	class AliHBTMonPzDistributionFctn;
	12	class AliHBTMonPzDistributionVsPtFctn;
	13	class AliHBTMonPDistributionFctn;
	14	class AliHBTMonPDistributionVsPtFctn;
	15	class AliHBTMonPtDistributionFctn;
	16
	17	#include "AliHBTMonitorFunction.h"
	18	/***********************************************************************/
	19	/***********************************************************************/
	20	/*************************************************************************************/
	21
	22	class AliHBTMonPxDistributionFctn: public AliHBTMonOneParticleFctn1D
	23	{
	24	public:
	25	AliHBTMonPxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	26	virtual ~AliHBTMonPxDistributionFctn(){};
	27	TH1* GetResult(){return fResult;}
	28	protected:
	29	Double_t GetValue(AliHBTParticle * particle) { return particle->Px();}
	30	public:
	31	ClassDef(AliHBTMonPxDistributionFctn,1)
	32
	33	};
	34	/*************************************************************************************/
	35
	36	class AliHBTMonPyDistributionFctn: public AliHBTMonOneParticleFctn1D
	37	{
	38	public:
	39	AliHBTMonPyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	40	virtual ~AliHBTMonPyDistributionFctn(){};
	41	TH1* GetResult(){return fResult;}
	42	protected:
	43	Double_t GetValue(AliHBTParticle * particle) { return particle->Py();}
	44	public:
	45	ClassDef(AliHBTMonPyDistributionFctn,1)
	46
	47	};
	48	/*************************************************************************************/
	49
	50	class AliHBTMonPzDistributionFctn: public AliHBTMonOneParticleFctn1D
	51	{
	52	public:
	53	AliHBTMonPzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
	54	virtual ~AliHBTMonPzDistributionFctn(){};
	55	TH1* GetResult(){return fResult;}
	56	protected:
	57	Double_t GetValue(AliHBTParticle * particle) { return particle->Pz();}
	58	public:
	59	ClassDef(AliHBTMonPzDistributionFctn,1)
	60
	61	};
	62	/*************************************************************************************/
	63
	64	class AliHBTMonPDistributionFctn: public AliHBTMonOneParticleFctn1D
65	{
66	public:
67	AliHBTMonPDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
68	virtual ~AliHBTMonPDistributionFctn(){};
69	TH1* GetResult(){return fResult;}
70	protected:
71	Double_t GetValue(AliHBTParticle * particle) { return particle->P();}
72	public:
73	ClassDef(AliHBTMonPDistributionFctn,1)
74
75	};
76	/*************************************************************************************/
77
78	class AliHBTMonPtDistributionFctn: public AliHBTMonOneParticleFctn1D
79	{
80	public:
81	AliHBTMonPtDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
82	virtual ~AliHBTMonPtDistributionFctn(){};
83	TH1* GetResult(){return fResult;}
84	protected:
85	Double_t GetValue(AliHBTParticle * particle) { return particle->Pt();}
86	public:
87	ClassDef(AliHBTMonPtDistributionFctn,1)
88
89	};
90
91	/***********************************************************************/
92	class AliHBTMonPxDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
93	{
94	public:
95	AliHBTMonPxDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
96	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
97	virtual ~AliHBTMonPxDistributionVsPtFctn(){}
98
99	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
100	{
101	x = partparticle->Pt();
102	y = partparticle->Px();
103	}
104	TH1* GetResult(){return fResult;}
105	protected:
106	private:
107	public:
108	ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
109	};
110
111	/***********************************************************************/
112	class AliHBTMonPyDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
113	{
114	public:
115	AliHBTMonPyDistributionVsPtFctn(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 ~AliHBTMonPyDistributionVsPtFctn(){}
118
119	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
120	{
121	x = partparticle->Pt();
122	y = partparticle->Py();
123	}
124	TH1* GetResult(){return fResult;}
125	protected:
126	private:
127	public:
128	ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
129	};
130	/***********************************************************************/
131	class AliHBTMonPzDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
132	{
133	public:
134	AliHBTMonPzDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
135	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
136	virtual ~AliHBTMonPzDistributionVsPtFctn(){}
137
138	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
139	{
140	x = partparticle->Pt();
141	y = partparticle->Pz();
142	}
143	TH1* GetResult(){return fResult;}
144	protected:
145	private:
146	public:
147	ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
148	};
149
150	/***********************************************************************/
151	class AliHBTMonPDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
152	{
153	public:
154	AliHBTMonPDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
155	Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
156	virtual ~AliHBTMonPDistributionVsPtFctn(){}
157
158	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
159	{
160	x = partparticle->Pt();
161	y = partparticle->P();
162	}
163	TH1* GetResult(){return fResult;}
164	protected:
165	private:
166	public:
167	ClassDef(AliHBTMonPDistributionVsPtFctn,1)
168	};
169
170	/***********************************************************************/
171	/***********************************************************************/
172	/***********************************************************************/
173	/***********************************************************************/
174
175	class AliHBTMonPhiDistributionFctn: public AliHBTMonOneParticleFctn1D
176	{
177	public:
178	AliHBTMonPhiDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
179	virtual ~AliHBTMonPhiDistributionFctn(){};
180	TH1* GetResult(){return fResult;}
181	protected:
182	Double_t GetValue(AliHBTParticle * particle) { return particle->Phi();}
183	public:
184	ClassDef(AliHBTMonPhiDistributionFctn,1)
185
186	};
187
188	/***********************************************************************/
189	class AliHBTMonThetaDistributionFctn: public AliHBTMonOneParticleFctn1D
190	{
191	public:
192	AliHBTMonThetaDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
193	virtual ~AliHBTMonThetaDistributionFctn(){};
194	TH1* GetResult(){return fResult;}
195	protected:
196	Double_t GetValue(AliHBTParticle * particle) { return particle->Theta();}
197	public:
198	ClassDef(AliHBTMonThetaDistributionFctn,1)
199
200	};
201	/***********************************************************************/
202	/***********************************************************************/
203	class AliHBTMonPhiDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
204	{
205	public:
206	AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
207	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
208	virtual ~AliHBTMonPhiDistributionVsPtFctn(){}
209
210	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
211	{
212	x = partparticle->Pt();
213	y = partparticle->Phi();
214	}
215	TH1* GetResult(){return fResult;}
216	protected:
217	private:
218	public:
219	ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
220	};
221
222	/***********************************************************************/
223	class AliHBTMonThetaDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
224	{
225	public:
226	AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
227	Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
228	virtual ~AliHBTMonThetaDistributionVsPtFctn(){}
229
230	void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
231	{
232	x = partparticle->Pt();
233	y = partparticle->Theta();
234	}
235	TH1* GetResult(){return fResult;}
236	protected:
237	private:
238	public:
239	ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
240	};
241
242	/***********************************************************************/
243	/***********************************************************************/
244	/***********************************************************************/
245	/***********************************************************************/
246	/***********************************************************************/
247
248	#endif