Commenting out unused variables
[u/mrichter/AliRoot.git] / HBTAN / AliHBTMonitorFunction.h
1 #ifndef ALIHBTMONITORFUNCTION_H
2 #define ALIHBTMONITORFUNCTION_H
3 //__________________________________________________________________
4 ////////////////////////////////////////////////////////////////////
5 //
6 // class AliHBTMonitorFunction
7 //
8 // class AliHBTMonOneParticleFctn
9 // class AliHBTMonTwoParticleFctn
10 //
11 // class AliHBTMonOneParticleFctn1D
12 // class AliHBTMonOneParticleFctn2D
13 // class AliHBTMonOneParticleFctn3D
14 //
15 // class AliHBTMonTwoParticleFctn1D
16 // class AliHBTMonTwoParticleFctn2D
17 // class AliHBTMonTwoParticleFctn3D
18 //
19 // Base Classes for monitoring functions
20 // author: chajecki@if.pw.edu.pl
21 //
22 /******************************************************************/
23 /*
24 Base classes for monitor functions
25
26           monitor function
27                /    \
28               /      \
29              /        \
30             /          \
31            /            \
32           /              \
33          /                \
34    one particle     two particle  
35      /  |  \            /  |  \
36     /   |   \          /   |   \
37    1D  2D   3D        1D  2D   3D
38
39 Zbigniew.Chajecki@cern.ch
40
41 */
42 ///////////////////////////////////////////////////////////////////////
43
44 #include "AliHBTParticleCut.h"
45
46 #include <TH2.h>
47 #include <TH3.h>
48
49 class AliHBTParticle;
50
51 class AliHBTMonitorFunction: public TNamed
52 //Abstract base class for HBT functions
53 {
54   public:
55     AliHBTMonitorFunction();
56     AliHBTMonitorFunction(const char* name,const char* title);
57     AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/);
58     virtual ~AliHBTMonitorFunction();
59     
60     AliHBTMonitorFunction& operator=(const AliHBTMonitorFunction& /*in*/);
61     
62     
63     virtual TH1* GetResult() = 0;
64
65     virtual void Write();
66     virtual void Init();
67     virtual const char* Name(){return GetName();}
68     void Rename(const Char_t * name); 
69     void Rename(const Char_t * name, const Char_t * title); 
70     
71     void SetParticleCut(AliHBTParticleCut* cut);
72
73     virtual AliHBTParticle* CheckParticle(AliHBTParticle* particle) const;
74
75   protected:
76     AliHBTParticleCut*      fParticleCut;//Particle cut
77     
78   private:  
79    ClassDef(AliHBTMonitorFunction,1)
80 };
81 /******************************************************************/
82 /******************************************************************/
83 inline AliHBTParticle* AliHBTMonitorFunction::CheckParticle(AliHBTParticle* particle) const
84 {
85   //check if particle meets the cut criteria
86   if(fParticleCut->Pass(particle)) //if the particle is BAD
87    { 
88      return 0x0;//it is BAD as well - so return
89    }
90   return particle; 
91 }
92
93 /******************************************************************/
94 /******************************************************************/
95 /******************************************************************/
96
97 class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
98 {
99   public:
100     AliHBTMonOneParticleFctn(){}
101     AliHBTMonOneParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
102     AliHBTMonOneParticleFctn(const AliHBTMonOneParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
103     virtual ~AliHBTMonOneParticleFctn(){}
104     
105     AliHBTMonOneParticleFctn& operator=(const AliHBTMonOneParticleFctn& /*in*/){MayNotUse("operator=");return *this;} 
106     
107     virtual void Process(AliHBTParticle* particle) = 0;
108     
109   protected:
110   private:  
111    ClassDef(AliHBTMonOneParticleFctn,1)
112   
113 };
114 /******************************************************************/
115 class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
116 {
117  public:
118   AliHBTMonOneParticleFctn1D();
119   AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
120   AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
121                       Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
122   AliHBTMonOneParticleFctn1D(const AliHBTMonOneParticleFctn1D& in):
123                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
124   
125   virtual ~AliHBTMonOneParticleFctn1D();
126   
127   AliHBTMonOneParticleFctn1D& operator=(const AliHBTMonOneParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}   
128   TH1* GetResult(){return this->fResult;}
129
130   void Process(AliHBTParticle* particle);
131
132  protected:
133   virtual Double_t GetValue(AliHBTParticle* particle) const = 0; 
134   TH1D* fResult;//histogram to be filled
135  private:
136   ClassDef(AliHBTMonOneParticleFctn1D,2)
137 };
138 /******************************************************************/
139  
140 class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
141 {
142  public:
143   AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
144                       Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
145   AliHBTMonOneParticleFctn2D(const AliHBTMonOneParticleFctn2D& in):
146                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
147   virtual ~AliHBTMonOneParticleFctn2D();
148   
149   AliHBTMonOneParticleFctn2D& operator=(const AliHBTMonOneParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}   
150   TH1* GetResult(){return this->fResult;}
151   
152   void Process(AliHBTParticle* particle);
153
154  protected:
155   virtual void GetValues(AliHBTParticle* particle, Double_t&, Double_t&) const = 0;
156
157   TH2D* fResult;//histogram to be filled
158   
159  private:
160   ClassDef(AliHBTMonOneParticleFctn2D,1)
161 };
162 /******************************************************************/
163 /******************************************************************/
164 /******************************************************************/
165
166 class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
167 {
168  public:
169   AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
170                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15, 
171                       Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
172   AliHBTMonOneParticleFctn3D(const AliHBTMonOneParticleFctn3D& in):
173                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
174             
175   virtual ~AliHBTMonOneParticleFctn3D();
176
177   AliHBTMonOneParticleFctn3D& operator=(const AliHBTMonOneParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}   
178   TH1* GetResult(){return this->fResult;}
179
180  protected:
181   TH3D* fResult;//histogram to be filled
182
183  private:
184   ClassDef(AliHBTMonOneParticleFctn3D,1)
185 };
186 /******************************************************************/
187 /******************************************************************/
188 class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
189 {
190   public:
191     AliHBTMonTwoParticleFctn(){};
192     AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
193     AliHBTMonTwoParticleFctn(const AliHBTMonTwoParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
194     virtual ~AliHBTMonTwoParticleFctn(){};
195     AliHBTMonTwoParticleFctn& operator=(const AliHBTMonTwoParticleFctn& /*in*/){MayNotUse("operator=");return *this;} 
196     
197     virtual void 
198     Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
199              
200   protected:
201   private:  
202    ClassDef(AliHBTMonTwoParticleFctn,1)
203   
204 };
205 /******************************************************************/
206
207 class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
208 {
209  public:
210   AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
211   AliHBTMonTwoParticleFctn1D(const char* name,const char* title,
212                       Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
213   AliHBTMonTwoParticleFctn1D(const AliHBTMonTwoParticleFctn1D& in):
214                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
215   virtual ~AliHBTMonTwoParticleFctn1D();
216   
217   AliHBTMonTwoParticleFctn1D& operator=(const AliHBTMonTwoParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}   
218   TH1* GetResult(){return this->fResult;}
219   
220   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
221   
222  protected:
223   virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) const = 0;
224
225   TH1D* fResult;//histogram to be filled
226
227  private:
228   ClassDef(AliHBTMonTwoParticleFctn1D,1)
229 };
230 /******************************************************************/
231 class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
232 {
233  public:
234   AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
235                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
236   AliHBTMonTwoParticleFctn2D(const AliHBTMonTwoParticleFctn2D& in):
237                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
238   virtual ~AliHBTMonTwoParticleFctn2D();
239   
240   AliHBTMonTwoParticleFctn2D& operator=(const AliHBTMonTwoParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}   
241   TH1* GetResult(){return this->fResult;}
242   
243   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
244   
245  protected:
246   virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&) const = 0;
247
248   TH2D* fResult;//histogram to be filled
249   
250  private:
251   ClassDef(AliHBTMonTwoParticleFctn2D,1)
252 };
253
254
255 /******************************************************************/
256 class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
257 {
258  public:
259   AliHBTMonTwoParticleFctn3D(Int_t /*nXbins = 200*/, Double_t /*maxXval = 1.5*/, Double_t /*minXval = 0.0*/, 
260                              Int_t /*nYbins = 200*/, Double_t /*maxYval = .15*/, Double_t /*minYval =-0.15*/, 
261                              Int_t /*nZbins = 200*/, Double_t /*maxZval = .15*/, Double_t /*minZval =-0.15*/){}
262   AliHBTMonTwoParticleFctn3D(const AliHBTMonTwoParticleFctn3D& in):
263                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
264   virtual ~AliHBTMonTwoParticleFctn3D(){}
265   
266   AliHBTMonTwoParticleFctn3D& operator=(const AliHBTMonTwoParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}   
267   TH1* GetResult(){return this->fResult;}
268   
269   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
270
271  protected:
272   virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&,Double_t&) const = 0;
273
274   TH3D* fResult; //histogram to be filled
275   
276  private:
277   ClassDef(AliHBTMonTwoParticleFctn3D,1)
278 };
279
280 /******************************************************************/
281 /******************************************************************/
282 /******************************************************************/
283 /******************************************************************/
284
285 #endif