1 #ifndef ALIHBTFUNCTION_H
2 #define ALIHBTFUNCTION_H
6 ///////////////////////////////////////////////////////
10 // Abstract Base Calss for all the function classes //
12 // Piotr.Skowronski@cern.ch //
13 // http://aliweb.cern.ch/people/skowron/analyzer //
15 ///////////////////////////////////////////////////////
21 #include "AliAODPairCut.h"
22 #include "AliHBTPair.h"
26 class AliVAODParticleCut;
28 class AliHBTFunction: public TNamed
32 AliHBTFunction(const char* name, const char* title);
33 AliHBTFunction(const AliHBTFunction & source);
35 virtual ~AliHBTFunction();
37 AliHBTFunction & operator= (const AliHBTFunction & source);
39 virtual TH1* GetNumerator() const = 0;
40 virtual TH1* GetDenominator() const = 0;
41 virtual TH1* GetResult() = 0;
43 virtual Int_t WriteFunction();
44 virtual void InitFunction();
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
50 void SetPairCut(AliAODPairCut* cut);
51 void UseAbsoluteValues(Bool_t flag){fAbs = flag;}
53 virtual AliHBTPair* CheckPair(AliHBTPair* pair);
54 void SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
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
61 ClassDef(AliHBTFunction,3)
63 /******************************************************************/
64 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
66 //check if pair and both particles meets the cut criteria
67 if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
69 // It is not allowed to change the order here beacause analysis enforce the order
72 // pair = pair->GetSwappedPair();
74 // if(fPairCut->Rejected(pair)) //so try reverse combination
76 // return 0x0;//it is BAD as well - so return
83 /******************************************************************/
84 /******************************************************************/
85 /******************************************************************/
86 class AliHBTCorrelFunction
89 AliHBTCorrelFunction():fRatio(0x0){}
90 AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
91 virtual ~AliHBTCorrelFunction(){delete fRatio;}
93 AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
96 TH1* fRatio;//!pointer to the ratio(result)
98 ClassDef(AliHBTCorrelFunction,1)
101 /******************************************************************/
102 /******************************************************************/
103 /******************************************************************/
105 //____________________
106 ///////////////////////////////////////////////////////
108 // AliHBTOnePairFctn //
110 // Abstract Base Calss for Functions that need //
111 // one pair to fill function //
113 // Piotr.Skowronski@cern.ch //
114 // http://aliweb.cern.ch/people/skowron/analyzer //
116 ///////////////////////////////////////////////////////
118 class AliHBTOnePairFctn
121 AliHBTOnePairFctn(){}
122 virtual ~AliHBTOnePairFctn(){}
124 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
125 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
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;
131 ClassDef(AliHBTOnePairFctn,2)
133 /******************************************************************/
134 /******************************************************************/
135 /******************************************************************/
137 //____________________
138 ///////////////////////////////////////////////////////
140 // AliHBTTwoPairFctn //
142 // Abstract Base Calss for Functions that need //
143 // two pairs to fill function, //
144 // one reconstructed track and corresponding //
146 // Basically resolution functions //
147 // Lednicky's algorithm uses that as well //
149 // Piotr.Skowronski@cern.ch //
150 // http://aliweb.cern.ch/people/skowron/analyzer //
152 ///////////////////////////////////////////////////////
154 class AliHBTTwoPairFctn
157 AliHBTTwoPairFctn(){};
158 virtual ~AliHBTTwoPairFctn(){};
161 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
163 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
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;
169 ClassDef(AliHBTTwoPairFctn,2)
172 /******************************************************************/
173 /******************************************************************/
174 /******************************************************************/
176 //____________________
177 ///////////////////////////////////////////////////////
179 // AliHBTFunction1D //
181 // Base Calss for 1-dimensinal Functions //
183 // Piotr.Skowronski@cern.ch //
184 // http://aliweb.cern.ch/people/skowron/analyzer //
186 ///////////////////////////////////////////////////////
189 class AliHBTFunction1D: public AliHBTFunction
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);
198 AliHBTFunction1D(const AliHBTFunction1D & source);
199 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
201 virtual ~AliHBTFunction1D();
203 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
204 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
207 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
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);
215 TH1D* fNumerator; // Numerator histogram
216 TH1D* fDenominator; // Denumerator histogram
217 UInt_t fNBinsToScale; // Number of bins to scale
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
226 ClassDef(AliHBTFunction1D,2)
229 /******************************************************************/
230 /******************************************************************/
231 /******************************************************************/
233 //____________________
234 ///////////////////////////////////////////////////////
236 // AliHBTFunction2D //
238 // Base Calss for 2-dimensinal Functions //
240 // Piotr.Skowronski@cern.ch //
241 // http://aliweb.cern.ch/people/skowron/analyzer //
243 ///////////////////////////////////////////////////////
245 class AliHBTFunction2D: public AliHBTFunction
250 AliHBTFunction2D(const Char_t *name, const Char_t *title);
252 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
253 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
259 AliHBTFunction2D(const AliHBTFunction2D & source);
261 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
263 virtual ~AliHBTFunction2D();
265 TH1* GetNumerator() const {return fNumerator;}
266 TH1* GetDenominator() const {return fDenominator;}
268 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
269 UInt_t yn = fgkDefaultNBinsToScaleY);
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();
277 TH2D* fNumerator; // Numerator histogram
278 TH2D* fDenominator; // Denominator histogram
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
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
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
297 ClassDef(AliHBTFunction2D,2)
299 /******************************************************************/
300 /******************************************************************/
301 /******************************************************************/
303 //____________________
304 ///////////////////////////////////////////////////////
306 // AliHBTFunction3D //
308 // Base Calss for 3-dimensinal Functions that need //
309 // one pair to fill function //
311 // Piotr.Skowronski@cern.ch //
312 // http://aliweb.cern.ch/people/skowron/analyzer //
314 ///////////////////////////////////////////////////////
316 class AliHBTFunction3D: public AliHBTFunction
321 AliHBTFunction3D(const Char_t *name, const Char_t *title);
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);
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);
332 AliHBTFunction3D(const AliHBTFunction3D & source);
333 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
335 virtual ~AliHBTFunction3D();//destructor
337 TH1* GetNumerator() const {return fNumerator;}
338 TH1* GetDenominator() const {return fDenominator;}
341 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
342 UInt_t yn = fgkDefaultNBinsToScaleY,
343 UInt_t zn = fgkDefaultNBinsToScaleZ);
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();
353 TH3F* fNumerator; // Numerator histogram
354 TH3F* fDenominator; // Denominator histogram
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
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
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
378 ClassDef(AliHBTFunction3D,2)
380 /******************************************************************/
381 /******************************************************************/
382 /******************************************************************/
384 //____________________
385 ///////////////////////////////////////////////////////
387 // AliHBTOnePairFctn1D //
389 // Base Calss for 1-dimensinal Functions that need //
390 // one pair to fill function //
392 // Piotr.Skowronski@cern.ch //
393 // http://aliweb.cern.ch/people/skowron/analyzer //
395 ///////////////////////////////////////////////////////
397 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
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(){}
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();}
415 //retruns velue to be histogrammed
416 virtual Double_t GetValue(AliHBTPair* pair) const = 0;
417 ClassDef(AliHBTOnePairFctn1D,2)
419 /******************************************************************/
420 /******************************************************************/
421 /******************************************************************/
423 //____________________
424 ///////////////////////////////////////////////////////
426 // AliHBTOnePairFctn2D //
428 // Base Calss for 2-dimensinal Functions that need //
429 // one pair to fill function //
431 // Piotr.Skowronski@cern.ch //
432 // http://aliweb.cern.ch/people/skowron/analyzer //
434 ///////////////////////////////////////////////////////
436 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
439 AliHBTOnePairFctn2D(){}
441 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
443 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
444 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
450 virtual ~AliHBTOnePairFctn2D(){}
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();}
459 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
460 ClassDef(AliHBTOnePairFctn2D,2)
462 /******************************************************************/
463 /******************************************************************/
464 /******************************************************************/
466 //____________________
467 ///////////////////////////////////////////////////////
469 // AliHBTOnePairFctn3D //
471 // Base Calss for 3-dimensinal Functions that need //
472 // one pair to fill function //
474 // Piotr.Skowronski@cern.ch //
475 // http://aliweb.cern.ch/people/skowron/analyzer //
477 ///////////////////////////////////////////////////////
479 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
482 AliHBTOnePairFctn3D(){}
484 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
495 virtual ~AliHBTOnePairFctn3D(){}//destructor
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();}
504 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
505 ClassDef(AliHBTOnePairFctn3D,2)
507 /******************************************************************/
508 /******************************************************************/
509 /******************************************************************/
511 //____________________
512 ///////////////////////////////////////////////////////
514 // AliHBTTwoPairFctn1D //
516 // Base Calss for 1-dimensinal Functions that need //
517 // two pair (simulated and reconstructed) //
518 // to fill function //
520 // Piotr.Skowronski@cern.ch //
521 // http://aliweb.cern.ch/people/skowron/analyzer //
523 ///////////////////////////////////////////////////////
525 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
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(){}
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();}
543 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
545 ClassDef(AliHBTTwoPairFctn1D,2)
547 /******************************************************************/
548 /******************************************************************/
549 /******************************************************************/
551 //____________________
552 ///////////////////////////////////////////////////////
554 // AliHBTTwoPairFctn2D //
556 // Base Calss for 2-dimensinal Functions that need //
557 // two pair (simulated and reconstructed) //
558 // to fill function //
560 // Piotr.Skowronski@cern.ch //
561 // http://aliweb.cern.ch/people/skowron/analyzer //
563 ///////////////////////////////////////////////////////
565 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
568 AliHBTTwoPairFctn2D(){}
570 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
572 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
573 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
579 virtual ~AliHBTTwoPairFctn2D(){}
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();}
589 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
591 ClassDef(AliHBTTwoPairFctn2D,2)
593 /******************************************************************/
594 /******************************************************************/
595 /******************************************************************/
597 //____________________
598 ///////////////////////////////////////////////////////
600 // AliHBTTwoPairFctn3D //
602 // Base Calss for 3-dimensinal Functions that need //
603 // two pair (simulated and reconstructed) //
604 // to fill function //
606 // Piotr.Skowronski@cern.ch //
607 // http://aliweb.cern.ch/people/skowron/analyzer //
609 ///////////////////////////////////////////////////////
611 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
614 AliHBTTwoPairFctn3D(){}
616 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
627 virtual ~AliHBTTwoPairFctn3D(){}//destructor
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();}
637 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
639 ClassDef(AliHBTTwoPairFctn3D,2)