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

#ifndef ALIMONPXRESOLUTIONVSPTFCTN_H
#define ALIMONPXRESOLUTIONVSPTFCTN_H

// added by Zbigniew.Chajecki@cern.ch
// this classes create resolution functions of particle momentum 

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

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


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

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

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

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

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

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

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

   Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle) 
     { 
        return (partparticle->Theta()-trackparticle->Theta()) ;
     } 
   TH1* GetResult(){return fResult;} 
  protected:
  private:
  public:
    ClassDef(AliHBTMonThetaResolutionFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
class AliHBTMonPhiResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonPhiResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonPhiResolutionVsPtFctn(){}
   TH1* GetResult(){return fResult;}
   void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->Phi()-trackparticle->Phi();
    }
  protected:
  private:
  public:
    ClassDef(AliHBTMonPhiResolutionVsPtFctn,1)
 };
/***********************************************************************/
class AliHBTMonThetaResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
 {
  public: 
   AliHBTMonThetaResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1, 
                             Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
   virtual ~AliHBTMonThetaResolutionVsPtFctn(){}
   TH1* GetResult(){return fResult;}
   void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
    {
     x = partparticle->Pt();
     y = partparticle->Theta()-trackparticle->Theta();
    }
  protected:
  private:
  public:
    ClassDef(AliHBTMonThetaResolutionVsPtFctn,1)
 };
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/

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