Removing compilaton warnings
[u/mrichter/AliRoot.git] / HBTAN / AliHBTFunction.h
1 #ifndef ALIHBTFUNCTION_H
2 #define ALIHBTFUNCTION_H
3  
4 /* Id: $ */
5
6 ///////////////////////////////////////////////////////
7 //                                                   //
8 // AliHBTFunction                                    //
9 //                                                   //
10 // Abstract Base Calss for all the function classes  //
11 //                                                   //
12 // Piotr.Skowronski@cern.ch                          //
13 // http://aliweb.cern.ch/people/skowron/analyzer    //
14 //                                                   //
15 ///////////////////////////////////////////////////////
16
17 #include <TH1.h>
18 #include <TH2D.h>
19 #include <TH3D.h>
20
21 #include "AliAODPairCut.h"
22 #include "AliHBTPair.h"
23
24
25 class AliHBTAnalysis;
26 class AliVAODParticleCut;
27
28 class AliHBTFunction: public TNamed
29 {
30   public:
31     AliHBTFunction();
32     AliHBTFunction(const char* name, const char* title);
33     AliHBTFunction(const AliHBTFunction & source);
34     
35     virtual ~AliHBTFunction();
36     
37     AliHBTFunction & operator= (const AliHBTFunction & source);
38
39     virtual TH1* GetNumerator() const = 0;
40     virtual TH1* GetDenominator() const = 0;
41     virtual TH1* GetResult() = 0;
42
43     virtual Int_t WriteFunction();
44     virtual void InitFunction();
45     
46     TH1* GetRatio(Double_t normfactor = 1.0);
47     void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
48     void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
49     
50     void SetPairCut(AliAODPairCut* cut);
51     void UseAbsoluteValues(Bool_t flag){fAbs = flag;}
52     
53     virtual AliHBTPair* CheckPair(AliHBTPair* pair);
54     void  SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
55   protected:
56     virtual void BuildHistos() = 0;//builds default histograms
57     AliAODPairCut*   fPairCut;     //pair cut
58     Bool_t           fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
59     Bool_t           fAbs;//flag indicating if absolute values of qout, qside and qlong should be histogrammed
60     
61     ClassDef(AliHBTFunction,3)
62 };
63 /******************************************************************/
64 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
65 {
66   //check if pair and both particles meets the cut criteria
67   if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
68
69 //   It is not allowed to change the order here beacause analysis enforce the order
70
71 //   {//it is BAD 
72 //    pair = pair->GetSwappedPair();
73 //    if(pair)
74 //     if(fPairCut->Rejected(pair)) //so try reverse combination
75 //       { 
76 //        return 0x0;//it is BAD as well - so return
77 //       }
78 //   }
79
80   return pair; 
81 }
82
83 /******************************************************************/
84 /******************************************************************/
85 /******************************************************************/
86 class AliHBTCorrelFunction
87 {
88   public:
89     AliHBTCorrelFunction():fRatio(0x0){}
90     AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
91     virtual ~AliHBTCorrelFunction(){delete fRatio;}
92     
93     AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
94    
95   protected:
96     TH1* fRatio;//!pointer to the ratio(result)
97     
98   ClassDef(AliHBTCorrelFunction,1)
99 };
100
101 /******************************************************************/
102 /******************************************************************/
103 /******************************************************************/
104
105 //____________________
106 ///////////////////////////////////////////////////////
107 //                                                   //
108 // AliHBTOnePairFctn                                 //
109 //                                                   //
110 // Abstract Base Calss for Functions that need       //
111 // one pair to fill function                         //
112 //                                                   //
113 // Piotr.Skowronski@cern.ch                          //
114 // http://aliweb.cern.ch/people/skowron/analyzer    //
115 //                                                   //
116 ///////////////////////////////////////////////////////
117
118 class AliHBTOnePairFctn
119 {
120   public:
121     AliHBTOnePairFctn(){}
122     virtual ~AliHBTOnePairFctn(){}
123     
124     virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
125     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
126
127     virtual void Init() = 0;
128     virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
129     virtual const char* Name() = 0;
130     
131    ClassDef(AliHBTOnePairFctn,2)
132 };
133 /******************************************************************/
134 /******************************************************************/
135 /******************************************************************/
136
137 //____________________
138 ///////////////////////////////////////////////////////
139 //                                                   //
140 // AliHBTTwoPairFctn                                 //
141 //                                                   //
142 // Abstract Base Calss for Functions that need       //
143 // two pairs to fill function,                       //
144 // one reconstructed track and corresponding         //
145 // simulated pair                                    //
146 // Basically resolution functions                    //
147 // Lednicky's algorithm uses that as well            //
148 //                                                   //
149 // Piotr.Skowronski@cern.ch                          //
150 // http://aliweb.cern.ch/people/skowron/analyzer    //
151 //                                                   //
152 ///////////////////////////////////////////////////////
153
154 class AliHBTTwoPairFctn
155 {
156   public:
157     AliHBTTwoPairFctn(){};
158     virtual ~AliHBTTwoPairFctn(){};
159     
160     virtual void 
161     ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
162     virtual void 
163     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
164     
165     virtual void Init() = 0;
166     virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
167     virtual const char* Name() = 0;
168              
169    ClassDef(AliHBTTwoPairFctn,2)
170   
171 };
172 /******************************************************************/
173 /******************************************************************/
174 /******************************************************************/
175
176 //____________________
177 ///////////////////////////////////////////////////////
178 //                                                   //
179 // AliHBTFunction1D                                  //
180 //                                                   //
181 // Base Calss for 1-dimensinal Functions             //
182 //                                                   //
183 // Piotr.Skowronski@cern.ch                          //
184 // http://aliweb.cern.ch/people/skowron/analyzer    //
185 //                                                   //
186 ///////////////////////////////////////////////////////
187
188
189 class AliHBTFunction1D: public AliHBTFunction
190 {
191  public:
192   AliHBTFunction1D();//default conmstructor
193   AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
194   AliHBTFunction1D(const Char_t *name, const Char_t *title);
195   AliHBTFunction1D(const Char_t *name, const Char_t *title,
196                    Int_t nbins, Float_t maxXval, Float_t minXval);
197
198   AliHBTFunction1D(const AliHBTFunction1D & source);
199   AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
200
201   virtual ~AliHBTFunction1D();
202   
203   TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
204   TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
205
206   Double_t Scale();
207   void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
208
209  protected:
210   //returns value to be histogrammed
211   virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
212   virtual void BuildHistos();
213   Double_t Scale(TH1D* num,TH1D* den);
214   
215   TH1D* fNumerator; // Numerator histogram
216   TH1D* fDenominator; // Denumerator histogram
217   UInt_t fNBinsToScale; // Number of bins to scale
218
219  private:
220   //this must be declared before constructors because they are used as a default arguments
221   static const Int_t fgkDefaultNBins;//default number of Bins in histograms
222   static const Float_t fgkDefaultMin;//Default min value of histograms
223   static const Float_t fgkDefaultMax;//Default max value of histograms
224   static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
225
226   ClassDef(AliHBTFunction1D,2)
227 };
228
229 /******************************************************************/
230 /******************************************************************/
231 /******************************************************************/
232
233 //____________________
234 ///////////////////////////////////////////////////////
235 //                                                   //
236 // AliHBTFunction2D                                  //
237 //                                                   //
238 // Base Calss for 2-dimensinal Functions             //
239 //                                                   //
240 // Piotr.Skowronski@cern.ch                          //
241 // http://aliweb.cern.ch/people/skowron/analyzer    //
242 //                                                   //
243 ///////////////////////////////////////////////////////
244  
245 class AliHBTFunction2D: public AliHBTFunction
246 {
247  public:
248   AliHBTFunction2D();
249
250   AliHBTFunction2D(const Char_t *name, const Char_t *title);
251
252   AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
253                       Int_t nYbins, Double_t maxYval, Double_t minYval);
254
255   AliHBTFunction2D(const Char_t *name, const Char_t *title,
256                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
257                       Int_t nYbins, Double_t maxYval, Double_t minYval);
258           
259   AliHBTFunction2D(const AliHBTFunction2D & source);
260
261   AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
262
263   virtual ~AliHBTFunction2D();
264   
265   TH1* GetNumerator() const {return fNumerator;}
266   TH1* GetDenominator() const {return fDenominator;}
267   
268   void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, 
269                               UInt_t yn = fgkDefaultNBinsToScaleY);
270   
271   Double_t Scale();
272  protected:
273   virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
274                            Int_t nybins, Float_t ymax, Float_t ymin);
275   virtual void BuildHistos();
276   
277   TH2D* fNumerator; // Numerator histogram
278   TH2D* fDenominator; // Denominator histogram
279   
280   //definition of area used for scaling -> Scale is calculated this 
281   //way that after division tale is on 1
282   UInt_t fNBinsToScaleX;//number of bins on X axis
283   UInt_t fNBinsToScaleY;//number of bins on Y axis
284
285  private:
286   //this must be declared before constructors because they are used as a default arguments
287   static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
288   static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
289   static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
290   static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
291   static const Float_t fgkDefaultMinY;//Default min value of histograms
292   static const Float_t fgkDefaultMaxY;//Default max value of histograms
293
294   static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
295   static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
296
297   ClassDef(AliHBTFunction2D,2)
298 };
299 /******************************************************************/
300 /******************************************************************/
301 /******************************************************************/
302
303 //____________________
304 ///////////////////////////////////////////////////////
305 //                                                   //
306 // AliHBTFunction3D                               //
307 //                                                   //
308 // Base Calss for 3-dimensinal Functions that need   //
309 // one pair to fill function                         //
310 //                                                   //
311 // Piotr.Skowronski@cern.ch                          //
312 // http://aliweb.cern.ch/people/skowron/analyzer    //
313 //                                                   //
314 ///////////////////////////////////////////////////////
315
316 class AliHBTFunction3D: public AliHBTFunction
317 {
318  public:
319   AliHBTFunction3D();
320
321   AliHBTFunction3D(const Char_t *name, const Char_t *title);
322
323   AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
324                    Int_t nYbins, Double_t maxYval, Double_t minYval, 
325                    Int_t nZbins, Double_t maxZval, Double_t minZval);
326
327   AliHBTFunction3D(const Char_t *name, const Char_t *title,
328                    Int_t nXbins, Double_t maxXval, Double_t minXval, 
329                    Int_t nYbins, Double_t maxYval, Double_t minYval, 
330                    Int_t nZbins, Double_t maxZval, Double_t minZval);
331
332   AliHBTFunction3D(const AliHBTFunction3D & source);
333   AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
334
335   virtual ~AliHBTFunction3D();//destructor
336
337   TH1* GetNumerator() const {return fNumerator;}
338   TH1* GetDenominator() const {return fDenominator;}
339
340
341   void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, 
342                               UInt_t yn = fgkDefaultNBinsToScaleY,
343                               UInt_t zn = fgkDefaultNBinsToScaleZ);
344
345   Double_t Scale();
346
347  protected:
348   virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
349                            Int_t nybins, Float_t ymax, Float_t ymin,
350                Int_t nzbins, Float_t zmax, Float_t zmin);
351   virtual void BuildHistos();
352   
353   TH3F* fNumerator; // Numerator histogram
354   TH3F* fDenominator; // Denominator histogram
355   
356   //definition of area used for scaling -> Scale is calculated this 
357   //way that after division tale is on 1
358   UInt_t fNBinsToScaleX;//number of bins on X axis
359   UInt_t fNBinsToScaleY;//number of bins on Y axis
360   UInt_t fNBinsToScaleZ;//number of bins on Z axis
361   
362  private:
363   //this must be declared before constructors because they are used as a default arguments
364   static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
365   static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
366   static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
367   static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
368   static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
369   static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
370   static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
371   static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
372   static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
373
374   static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
375   static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
376   static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
377   
378   ClassDef(AliHBTFunction3D,2)
379 };
380 /******************************************************************/
381 /******************************************************************/
382 /******************************************************************/
383
384 //____________________
385 ///////////////////////////////////////////////////////
386 //                                                   //
387 // AliHBTOnePairFctn1D                               //
388 //                                                   //
389 // Base Calss for 1-dimensinal Functions that need   //
390 // one pair to fill function                         //
391 //                                                   //
392 // Piotr.Skowronski@cern.ch                          //
393 // http://aliweb.cern.ch/people/skowron/analyzer    //
394 //                                                   //
395 ///////////////////////////////////////////////////////
396
397 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
398 {
399  public:
400   AliHBTOnePairFctn1D(){}//default conmstructor
401   AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
402   AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title);
403   AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
404                       Int_t nbins, Float_t maxXval, Float_t minXval);
405   virtual ~AliHBTOnePairFctn1D(){}
406
407   void ProcessSameEventParticles(AliHBTPair* pair);
408   void ProcessDiffEventParticles(AliHBTPair* pair);
409   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
410   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
411   void Init(){InitFunction();}
412   const char* Name(){return GetName();}
413   
414  protected:
415   //retruns velue to be histogrammed
416   virtual Double_t GetValue(AliHBTPair* pair) const = 0; 
417   ClassDef(AliHBTOnePairFctn1D,2)
418 };
419 /******************************************************************/
420 /******************************************************************/
421 /******************************************************************/
422
423 //____________________
424 ///////////////////////////////////////////////////////
425 //                                                   //
426 // AliHBTOnePairFctn2D                               //
427 //                                                   //
428 // Base Calss for 2-dimensinal Functions that need   //
429 // one pair to fill function                         //
430 //                                                   //
431 // Piotr.Skowronski@cern.ch                          //
432 // http://aliweb.cern.ch/people/skowron/analyzer    //
433 //                                                   //
434 ///////////////////////////////////////////////////////
435
436 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
437 {
438  public:
439   AliHBTOnePairFctn2D(){}
440
441   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
442
443   AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
444                       Int_t nYbins, Double_t maxYval, Double_t minYval);
445
446   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
447                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
448                       Int_t nYbins, Double_t maxYval, Double_t minYval);
449           
450   virtual ~AliHBTOnePairFctn2D(){}
451   
452   void ProcessSameEventParticles(AliHBTPair* pair);
453   void ProcessDiffEventParticles(AliHBTPair* pair);
454   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
455   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
456   void Init(){InitFunction();}
457   const char* Name(){return GetName();}
458  protected:
459   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
460   ClassDef(AliHBTOnePairFctn2D,2)
461 };
462 /******************************************************************/
463 /******************************************************************/
464 /******************************************************************/
465
466 //____________________
467 ///////////////////////////////////////////////////////
468 //                                                   //
469 // AliHBTOnePairFctn3D                               //
470 //                                                   //
471 // Base Calss for 3-dimensinal Functions that need   //
472 // one pair to fill function                         //
473 //                                                   //
474 // Piotr.Skowronski@cern.ch                          //
475 // http://aliweb.cern.ch/people/skowron/analyzer    //
476 //                                                   //
477 ///////////////////////////////////////////////////////
478
479 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
480 {
481  public:
482   AliHBTOnePairFctn3D(){}
483
484   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
485
486   AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
487                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
488                       Int_t nZbins, Double_t maxZval, Double_t minZval);
489
490   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
491                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
492                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
493                       Int_t nZbins, Double_t maxZval, Double_t minZval);
494    
495   virtual ~AliHBTOnePairFctn3D(){}//destructor
496
497   void ProcessSameEventParticles(AliHBTPair* pair);
498   void ProcessDiffEventParticles(AliHBTPair* pair);
499   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
500   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
501   void Init(){InitFunction();}
502   const char* Name(){return GetName();}
503  protected:
504   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
505  ClassDef(AliHBTOnePairFctn3D,2)
506 };
507 /******************************************************************/
508 /******************************************************************/
509 /******************************************************************/
510
511 //____________________
512 ///////////////////////////////////////////////////////
513 //                                                   //
514 // AliHBTTwoPairFctn1D                               //
515 //                                                   //
516 // Base Calss for 1-dimensinal Functions that need   //
517 // two pair (simulated and reconstructed)            //
518 // to fill function                                  //
519 //                                                   //
520 // Piotr.Skowronski@cern.ch                          //
521 // http://aliweb.cern.ch/people/skowron/analyzer    //
522 //                                                   //
523 ///////////////////////////////////////////////////////
524
525 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
526 {
527  public:
528   AliHBTTwoPairFctn1D(){}//default conmstructor
529   AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
530   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
531   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
532                       Int_t nbins, Float_t maxXval, Float_t minXval);
533   virtual ~AliHBTTwoPairFctn1D(){}
534
535   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
536   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
537   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
538   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
539   void Init(){InitFunction();}
540   const char* Name(){return GetName();}
541   
542  protected:
543   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
544
545   ClassDef(AliHBTTwoPairFctn1D,2)
546 };
547 /******************************************************************/
548 /******************************************************************/
549 /******************************************************************/
550
551 //____________________
552 ///////////////////////////////////////////////////////
553 //                                                   //
554 // AliHBTTwoPairFctn2D                               //
555 //                                                   //
556 // Base Calss for 2-dimensinal Functions that need   //
557 // two pair (simulated and reconstructed)            //
558 // to fill function                                  //
559 //                                                   //
560 // Piotr.Skowronski@cern.ch                          //
561 // http://aliweb.cern.ch/people/skowron/analyzer    //
562 //                                                   //
563 ///////////////////////////////////////////////////////
564
565 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
566 {
567  public:
568   AliHBTTwoPairFctn2D(){}
569
570   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
571
572   AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
573                       Int_t nYbins, Double_t maxYval, Double_t minYval);
574
575   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
576                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
577                       Int_t nYbins, Double_t maxYval, Double_t minYval);
578           
579   virtual ~AliHBTTwoPairFctn2D(){}
580   
581   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
582   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
583   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
584   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
585   void Init(){InitFunction();}
586   const char* Name(){return GetName();}
587
588  protected:
589   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
590
591   ClassDef(AliHBTTwoPairFctn2D,2)
592 };
593 /******************************************************************/
594 /******************************************************************/
595 /******************************************************************/
596
597 //____________________
598 ///////////////////////////////////////////////////////
599 //                                                   //
600 // AliHBTTwoPairFctn3D                               //
601 //                                                   //
602 // Base Calss for 3-dimensinal Functions that need   //
603 // two pair (simulated and reconstructed)            //
604 // to fill function                                  //
605 //                                                   //
606 // Piotr.Skowronski@cern.ch                          //
607 // http://aliweb.cern.ch/people/skowron/analyzer    //
608 //                                                   //
609 ///////////////////////////////////////////////////////
610
611 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
612 {
613  public:
614   AliHBTTwoPairFctn3D(){}
615   
616   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
617
618   AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
619                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
620                       Int_t nZbins, Double_t maxZval, Double_t minZval);
621
622   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
623                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
624                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
625                       Int_t nZbins, Double_t maxZval, Double_t minZval);
626    
627   virtual ~AliHBTTwoPairFctn3D(){}//destructor
628
629   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
630   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
631   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
632   Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
633   void Init(){InitFunction();}
634   const char* Name(){return GetName();}
635
636  protected:
637   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
638
639   ClassDef(AliHBTTwoPairFctn3D,2)
640 };
641
642 #endif