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