reverting to prev.
[u/mrichter/AliRoot.git] / HBTAN / AliHBTFunction.h
CommitLineData
1b446896 1#ifndef ALIHBTFUNCTION_H
2#define ALIHBTFUNCTION_H
6e8d850a 3
4/* Id: $ */
5
26f1270c 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
2dc7203b 17#include <TH1.h>
4e4af325 18#include <TH2D.h>
19#include <TH3D.h>
2dc7203b 20
21#include "AliHBTPairCut.h"
22#include "AliHBTPair.h"
23
2dc7203b 24
25class AliHBTAnalysis;
26class AliHBTParticleCut;
27
1b446896 28class AliHBTFunction: public TNamed
1b446896 29{
30 public:
31 AliHBTFunction();
28cf76fa 32 AliHBTFunction(const char* name, const char* title);
33 AliHBTFunction(const AliHBTFunction & source);
34
856180e9 35 virtual ~AliHBTFunction();
1b446896 36
28cf76fa 37 AliHBTFunction & operator= (const AliHBTFunction & source);
6e8d850a 38
26f1270c 39 virtual TH1* GetNumerator() const = 0;
40 virtual TH1* GetDenominator() const = 0;
1b446896 41 virtual TH1* GetResult() = 0;
976183fd 42
c41732dc 43 virtual void WriteFunction();
44 virtual void InitFunction();
1b446896 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
2dc7203b 50 void SetPairCut(AliHBTPairCut* cut);
1b446896 51
52 virtual AliHBTPair* CheckPair(AliHBTPair* pair);
e6e21fa2 53 void SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
1b446896 54 protected:
26f1270c 55 virtual void BuildHistos() = 0;//builds default histograms
2dc7203b 56 AliHBTPairCut* fPairCut; //pair cut
e6e21fa2 57 Bool_t fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
58 ClassDef(AliHBTFunction,3)
1b446896 59};
976183fd 60/******************************************************************/
1b446896 61inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
62{
63 //check if pair and both particles meets the cut criteria
7423906b 64 if(fPairCut->Pass(pair)) return 0x0; //if the pair is BAD
65
66// It is notallowed to change the order here beacause analysis enforce the order
67
68// {//it is BAD
69// pair = pair->GetSwapedPair();
70// if(pair)
71// if(fPairCut->Pass(pair)) //so try reverse combination
72// {
73// return 0x0;//it is BAD as well - so return
74// }
75// }
76
1b446896 77 return pair;
78}
79
1b446896 80/******************************************************************/
fc13079c 81/******************************************************************/
82/******************************************************************/
83class 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/******************************************************************/
1b446896 99/******************************************************************/
100/******************************************************************/
26f1270c 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
115class AliHBTOnePairFctn
1b446896 116{
117 public:
27b3fe5d 118 AliHBTOnePairFctn(){}
119 virtual ~AliHBTOnePairFctn(){}
1b446896 120
121 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
122 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
976183fd 123
26f1270c 124 virtual void Init() = 0;
125 virtual void Write() = 0;
8f0a515e 126 virtual const char* Name() = 0;
1b446896 127
26f1270c 128 ClassDef(AliHBTOnePairFctn,2)
1b446896 129};
130/******************************************************************/
131/******************************************************************/
132/******************************************************************/
26f1270c 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
151class AliHBTTwoPairFctn
1b446896 152{
153 public:
27b3fe5d 154 AliHBTTwoPairFctn(){};
155 virtual ~AliHBTTwoPairFctn(){};
1b446896 156
157 virtual void
158 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
159 virtual void
160 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
26f1270c 161
162 virtual void Init() = 0;
163 virtual void Write() = 0;
8f0a515e 164 virtual const char* Name() = 0;
1b446896 165
26f1270c 166 ClassDef(AliHBTTwoPairFctn,2)
1b446896 167
168};
169/******************************************************************/
170/******************************************************************/
171/******************************************************************/
172
26f1270c 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///////////////////////////////////////////////////////
1b446896 184
26f1270c 185
186class AliHBTFunction1D: public AliHBTFunction
1b446896 187{
188 public:
26f1270c 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);
28cf76fa 194
195 AliHBTFunction1D(const AliHBTFunction1D & source);
196 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
6e8d850a 197
26f1270c 198 virtual ~AliHBTFunction1D();
1b446896 199
26f1270c 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;}
1b446896 205
1b446896 206 protected:
6e8d850a 207 //returns value to be histogrammed
26f1270c 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
6e8d850a 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
26f1270c 222
26f1270c 223 ClassDef(AliHBTFunction1D,2)
1b446896 224};
225
1b446896 226/******************************************************************/
227/******************************************************************/
228/******************************************************************/
26f1270c 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///////////////////////////////////////////////////////
ba95ae3f 241
26f1270c 242class AliHBTFunction2D: public AliHBTFunction
1b446896 243{
244 public:
26f1270c 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
28cf76fa 256 AliHBTFunction2D(const AliHBTFunction2D & source);
257
258 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
6e8d850a 259
26f1270c 260 virtual ~AliHBTFunction2D();
1b446896 261
26f1270c 262 TH1* GetNumerator() const {return fNumerator;}
263 TH1* GetDenominator() const {return fDenominator;}
1b446896 264
26f1270c 265 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
266 UInt_t yn = fgkDefaultNBinsToScaleY);
267
268 Double_t Scale();
1b446896 269 protected:
26f1270c 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
6e8d850a 274 TH2D* fNumerator; // Numerator histogram
275 TH2D* fDenominator; // Denominator histogram
1b446896 276
26f1270c 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
6e8d850a 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
26f1270c 294 ClassDef(AliHBTFunction2D,2)
1b446896 295};
296/******************************************************************/
297/******************************************************************/
298/******************************************************************/
299
26f1270c 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
313class AliHBTFunction3D: public AliHBTFunction
1b446896 314{
315 public:
26f1270c 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);
6e8d850a 328
28cf76fa 329 AliHBTFunction3D(const AliHBTFunction3D & source);
330 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
6e8d850a 331
26f1270c 332 virtual ~AliHBTFunction3D();//destructor
333
334 TH1* GetNumerator() const {return fNumerator;}
335 TH1* GetDenominator() const {return fDenominator;}
1b446896 336
26f1270c 337
338 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
339 UInt_t yn = fgkDefaultNBinsToScaleY,
340 UInt_t zn = fgkDefaultNBinsToScaleZ);
341
342 Double_t Scale();
1b446896 343
344 protected:
26f1270c 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
dd82cadc 350 TH3F* fNumerator; // Numerator histogram
351 TH3F* fDenominator; // Denominator histogram
26f1270c 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
6e8d850a 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
26f1270c 375 ClassDef(AliHBTFunction3D,2)
1b446896 376};
377/******************************************************************/
378/******************************************************************/
379/******************************************************************/
380
26f1270c 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
394class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
ba95ae3f 395{
396 public:
26f1270c 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);
c41732dc 406 void Write(){WriteFunction();}
407 void Init(){InitFunction();}
8f0a515e 408 const char* Name(){return GetName();}
409
ba95ae3f 410 protected:
26f1270c 411 //retruns velue to be histogrammed
a22a56ec 412 virtual Double_t GetValue(AliHBTPair* pair) const = 0;
26f1270c 413 ClassDef(AliHBTOnePairFctn1D,2)
414};
415/******************************************************************/
416/******************************************************************/
417/******************************************************************/
ba95ae3f 418
26f1270c 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
432class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
433{
434 public:
435 AliHBTOnePairFctn2D(){}
4e871a8a 436
26f1270c 437 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
4e871a8a 438
26f1270c 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);
c41732dc 450 void Write(){WriteFunction();}
451 void Init(){InitFunction();}
8f0a515e 452 const char* Name(){return GetName();}
26f1270c 453 protected:
a22a56ec 454 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
26f1270c 455 ClassDef(AliHBTOnePairFctn2D,2)
ba95ae3f 456};
26f1270c 457/******************************************************************/
458/******************************************************************/
459/******************************************************************/
1b446896 460
26f1270c 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
474class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
475{
476 public:
477 AliHBTOnePairFctn3D(){}
1b446896 478
26f1270c 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);
c41732dc 494 void Write(){WriteFunction();}
495 void Init(){InitFunction();}
8f0a515e 496 const char* Name(){return GetName();}
26f1270c 497 protected:
a22a56ec 498 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
26f1270c 499 ClassDef(AliHBTOnePairFctn3D,2)
500};
1b446896 501/******************************************************************/
502/******************************************************************/
503/******************************************************************/
26f1270c 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
519class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
1b446896 520{
521 public:
26f1270c 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
1b446896 529 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
530 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
c41732dc 531 void Write(){WriteFunction();}
532 void Init(){InitFunction();}
8f0a515e 533 const char* Name(){return GetName();}
c41732dc 534
1b446896 535 protected:
a22a56ec 536 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
6e8d850a 537
26f1270c 538 ClassDef(AliHBTTwoPairFctn1D,2)
1b446896 539};
1b446896 540/******************************************************************/
541/******************************************************************/
542/******************************************************************/
26f1270c 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
558class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
ba95ae3f 559{
560 public:
26f1270c 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(){}
ba95ae3f 573
574 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
575 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
c41732dc 576 void Write(){WriteFunction();}
577 void Init(){InitFunction();}
8f0a515e 578 const char* Name(){return GetName();}
26f1270c 579
ba95ae3f 580 protected:
a22a56ec 581 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
ba95ae3f 582
26f1270c 583 ClassDef(AliHBTTwoPairFctn2D,2)
ba95ae3f 584};
1b446896 585/******************************************************************/
586/******************************************************************/
587/******************************************************************/
588
26f1270c 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
603class 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
1b446896 620
26f1270c 621 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
622 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
c41732dc 623 void Write(){WriteFunction();}
624 void Init(){InitFunction();}
8f0a515e 625 const char* Name(){return GetName();}
26f1270c 626
627 protected:
a22a56ec 628 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
26f1270c 629
26f1270c 630 ClassDef(AliHBTTwoPairFctn3D,2)
631};
1b446896 632
633#endif