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