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