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