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