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