- Setting Z positions of the tracking chamber to values given in Alain TOURNAIRE...
[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   void Init(){InitFunction();}
411   const char* Name(){return GetName();}
412   
413  protected:
414   //retruns velue to be histogrammed
415   virtual Double_t GetValue(AliHBTPair* pair) const = 0; 
416   ClassDef(AliHBTOnePairFctn1D,2)
417 };
418 /******************************************************************/
419 /******************************************************************/
420 /******************************************************************/
421
422 //____________________
423 ///////////////////////////////////////////////////////
424 //                                                   //
425 // AliHBTOnePairFctn2D                               //
426 //                                                   //
427 // Base Calss for 2-dimensinal Functions that need   //
428 // one pair to fill function                         //
429 //                                                   //
430 // Piotr.Skowronski@cern.ch                          //
431 // http://aliweb.cern.ch/people/skowron/analyzer    //
432 //                                                   //
433 ///////////////////////////////////////////////////////
434
435 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
436 {
437  public:
438   AliHBTOnePairFctn2D(){}
439
440   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
441
442   AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
443                       Int_t nYbins, Double_t maxYval, Double_t minYval);
444
445   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
446                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
447                       Int_t nYbins, Double_t maxYval, Double_t minYval);
448           
449   virtual ~AliHBTOnePairFctn2D(){}
450   
451   void ProcessSameEventParticles(AliHBTPair* pair);
452   void ProcessDiffEventParticles(AliHBTPair* pair);
453   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
454   void Init(){InitFunction();}
455   const char* Name(){return GetName();}
456  protected:
457   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
458   ClassDef(AliHBTOnePairFctn2D,2)
459 };
460 /******************************************************************/
461 /******************************************************************/
462 /******************************************************************/
463
464 //____________________
465 ///////////////////////////////////////////////////////
466 //                                                   //
467 // AliHBTOnePairFctn3D                               //
468 //                                                   //
469 // Base Calss for 3-dimensinal Functions that need   //
470 // one pair to fill function                         //
471 //                                                   //
472 // Piotr.Skowronski@cern.ch                          //
473 // http://aliweb.cern.ch/people/skowron/analyzer    //
474 //                                                   //
475 ///////////////////////////////////////////////////////
476
477 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
478 {
479  public:
480   AliHBTOnePairFctn3D(){}
481
482   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
483
484   AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
485                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
486                       Int_t nZbins, Double_t maxZval, Double_t minZval);
487
488   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
489                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
490                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
491                       Int_t nZbins, Double_t maxZval, Double_t minZval);
492    
493   virtual ~AliHBTOnePairFctn3D(){}//destructor
494
495   void ProcessSameEventParticles(AliHBTPair* pair);
496   void ProcessDiffEventParticles(AliHBTPair* pair);
497   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
498   void Init(){InitFunction();}
499   const char* Name(){return GetName();}
500  protected:
501   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
502  ClassDef(AliHBTOnePairFctn3D,2)
503 };
504 /******************************************************************/
505 /******************************************************************/
506 /******************************************************************/
507
508 //____________________
509 ///////////////////////////////////////////////////////
510 //                                                   //
511 // AliHBTTwoPairFctn1D                               //
512 //                                                   //
513 // Base Calss for 1-dimensinal Functions that need   //
514 // two pair (simulated and reconstructed)            //
515 // to fill function                                  //
516 //                                                   //
517 // Piotr.Skowronski@cern.ch                          //
518 // http://aliweb.cern.ch/people/skowron/analyzer    //
519 //                                                   //
520 ///////////////////////////////////////////////////////
521
522 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
523 {
524  public:
525   AliHBTTwoPairFctn1D(){}//default conmstructor
526   AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
527   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
528   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
529                       Int_t nbins, Float_t maxXval, Float_t minXval);
530   virtual ~AliHBTTwoPairFctn1D(){}
531
532   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
533   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
534   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
535   void Init(){InitFunction();}
536   const char* Name(){return GetName();}
537   
538  protected:
539   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
540
541   ClassDef(AliHBTTwoPairFctn1D,2)
542 };
543 /******************************************************************/
544 /******************************************************************/
545 /******************************************************************/
546
547 //____________________
548 ///////////////////////////////////////////////////////
549 //                                                   //
550 // AliHBTTwoPairFctn2D                               //
551 //                                                   //
552 // Base Calss for 2-dimensinal Functions that need   //
553 // two pair (simulated and reconstructed)            //
554 // to fill function                                  //
555 //                                                   //
556 // Piotr.Skowronski@cern.ch                          //
557 // http://aliweb.cern.ch/people/skowron/analyzer    //
558 //                                                   //
559 ///////////////////////////////////////////////////////
560
561 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
562 {
563  public:
564   AliHBTTwoPairFctn2D(){}
565
566   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
567
568   AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
569                       Int_t nYbins, Double_t maxYval, Double_t minYval);
570
571   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
572                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
573                       Int_t nYbins, Double_t maxYval, Double_t minYval);
574           
575   virtual ~AliHBTTwoPairFctn2D(){}
576   
577   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
578   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
579   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
580   void Init(){InitFunction();}
581   const char* Name(){return GetName();}
582
583  protected:
584   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
585
586   ClassDef(AliHBTTwoPairFctn2D,2)
587 };
588 /******************************************************************/
589 /******************************************************************/
590 /******************************************************************/
591
592 //____________________
593 ///////////////////////////////////////////////////////
594 //                                                   //
595 // AliHBTTwoPairFctn3D                               //
596 //                                                   //
597 // Base Calss for 3-dimensinal Functions that need   //
598 // two pair (simulated and reconstructed)            //
599 // to fill function                                  //
600 //                                                   //
601 // Piotr.Skowronski@cern.ch                          //
602 // http://aliweb.cern.ch/people/skowron/analyzer    //
603 //                                                   //
604 ///////////////////////////////////////////////////////
605
606 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
607 {
608  public:
609   AliHBTTwoPairFctn3D(){}
610   
611   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
612
613   AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
614                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
615                       Int_t nZbins, Double_t maxZval, Double_t minZval);
616
617   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
618                       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   virtual ~AliHBTTwoPairFctn3D(){}//destructor
623
624   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
625   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
626   Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
627   void Init(){InitFunction();}
628   const char* Name(){return GetName();}
629
630  protected:
631   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
632
633   ClassDef(AliHBTTwoPairFctn3D,2)
634 };
635
636 #endif