1 #ifndef ALIHBTFUNCTION_H
2 #define ALIHBTFUNCTION_H
6 ///////////////////////////////////////////////////////
10 // Abstract Base Calss for all the function classes //
12 // Piotr.Skowronski@cern.ch //
13 // http://alisoft.cern.ch/people/skowron/analyzer //
15 ///////////////////////////////////////////////////////
21 #include "AliHBTPairCut.h"
22 #include "AliHBTPair.h"
26 class AliHBTParticleCut;
28 class AliHBTFunction: public TNamed
32 AliHBTFunction(const char* name, const char* title);
33 AliHBTFunction(const AliHBTFunction & source);
35 virtual ~AliHBTFunction();
37 AliHBTFunction & operator= (const AliHBTFunction & source);
39 virtual TH1* GetNumerator() const = 0;
40 virtual TH1* GetDenominator() const = 0;
41 virtual TH1* GetResult() = 0;
43 virtual void WriteFunction();
44 virtual void InitFunction();
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
50 void SetPairCut(AliHBTPairCut* cut);
52 virtual AliHBTPair* CheckPair(AliHBTPair* pair);
53 void SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
55 virtual void BuildHistos() = 0;//builds default histograms
56 AliHBTPairCut* fPairCut; //pair cut
57 Bool_t fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
58 ClassDef(AliHBTFunction,3)
60 /******************************************************************/
61 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
63 //check if pair and both particles meets the cut criteria
64 if(fPairCut->Pass(pair)) //if the pair is BAD
66 pair = pair->GetSwapedPair();
68 if(fPairCut->Pass(pair)) //so try reverse combination
70 return 0x0;//it is BAD as well - so return
76 /******************************************************************/
77 /******************************************************************/
78 /******************************************************************/
79 class AliHBTCorrelFunction
82 AliHBTCorrelFunction():fRatio(0x0){}
83 AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
84 virtual ~AliHBTCorrelFunction(){delete fRatio;}
86 AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
89 TH1* fRatio;//!pointer to the ratio(result)
91 ClassDef(AliHBTCorrelFunction,1)
94 /******************************************************************/
95 /******************************************************************/
96 /******************************************************************/
98 //____________________
99 ///////////////////////////////////////////////////////
101 // AliHBTOnePairFctn //
103 // Abstract Base Calss for Functions that need //
104 // one pair to fill function //
106 // Piotr.Skowronski@cern.ch //
107 // http://alisoft.cern.ch/people/skowron/analyzer //
109 ///////////////////////////////////////////////////////
111 class AliHBTOnePairFctn
114 AliHBTOnePairFctn(){}
115 virtual ~AliHBTOnePairFctn(){}
117 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
118 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
120 virtual void Init() = 0;
121 virtual void Write() = 0;
122 virtual const char* Name() = 0;
124 ClassDef(AliHBTOnePairFctn,2)
126 /******************************************************************/
127 /******************************************************************/
128 /******************************************************************/
130 //____________________
131 ///////////////////////////////////////////////////////
133 // AliHBTTwoPairFctn //
135 // Abstract Base Calss for Functions that need //
136 // two pairs to fill function, //
137 // one reconstructed track and corresponding //
139 // Basically resolution functions //
140 // Lednicky's algorithm uses that as well //
142 // Piotr.Skowronski@cern.ch //
143 // http://alisoft.cern.ch/people/skowron/analyzer //
145 ///////////////////////////////////////////////////////
147 class AliHBTTwoPairFctn
150 AliHBTTwoPairFctn(){};
151 virtual ~AliHBTTwoPairFctn(){};
154 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
156 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
158 virtual void Init() = 0;
159 virtual void Write() = 0;
160 virtual const char* Name() = 0;
162 ClassDef(AliHBTTwoPairFctn,2)
165 /******************************************************************/
166 /******************************************************************/
167 /******************************************************************/
169 //____________________
170 ///////////////////////////////////////////////////////
172 // AliHBTFunction1D //
174 // Base Calss for 1-dimensinal Functions //
176 // Piotr.Skowronski@cern.ch //
177 // http://alisoft.cern.ch/people/skowron/analyzer //
179 ///////////////////////////////////////////////////////
182 class AliHBTFunction1D: public AliHBTFunction
185 AliHBTFunction1D();//default conmstructor
186 AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
187 AliHBTFunction1D(const Char_t *name, const Char_t *title);
188 AliHBTFunction1D(const Char_t *name, const Char_t *title,
189 Int_t nbins, Float_t maxXval, Float_t minXval);
191 AliHBTFunction1D(const AliHBTFunction1D & source);
192 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
194 virtual ~AliHBTFunction1D();
196 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
197 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
200 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
203 //returns value to be histogrammed
204 virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
205 virtual void BuildHistos();
206 Double_t Scale(TH1D* num,TH1D* den);
208 TH1D* fNumerator; // Numerator histogram
209 TH1D* fDenominator; // Denumerator histogram
210 UInt_t fNBinsToScale; // Number of bins to scale
213 //this must be declared before constructors because they are used as a default arguments
214 static const Int_t fgkDefaultNBins;//default number of Bins in histograms
215 static const Float_t fgkDefaultMin;//Default min value of histograms
216 static const Float_t fgkDefaultMax;//Default max value of histograms
217 static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
219 ClassDef(AliHBTFunction1D,2)
222 /******************************************************************/
223 /******************************************************************/
224 /******************************************************************/
226 //____________________
227 ///////////////////////////////////////////////////////
229 // AliHBTFunction2D //
231 // Base Calss for 2-dimensinal Functions //
233 // Piotr.Skowronski@cern.ch //
234 // http://alisoft.cern.ch/people/skowron/analyzer //
236 ///////////////////////////////////////////////////////
238 class AliHBTFunction2D: public AliHBTFunction
243 AliHBTFunction2D(const Char_t *name, const Char_t *title);
245 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
246 Int_t nYbins, Double_t maxYval, Double_t minYval);
248 AliHBTFunction2D(const Char_t *name, const Char_t *title,
249 Int_t nXbins, Double_t maxXval, Double_t minXval,
250 Int_t nYbins, Double_t maxYval, Double_t minYval);
252 AliHBTFunction2D(const AliHBTFunction2D & source);
254 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
256 virtual ~AliHBTFunction2D();
258 TH1* GetNumerator() const {return fNumerator;}
259 TH1* GetDenominator() const {return fDenominator;}
261 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
262 UInt_t yn = fgkDefaultNBinsToScaleY);
266 virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
267 Int_t nybins, Float_t ymax, Float_t ymin);
268 virtual void BuildHistos();
270 TH2D* fNumerator; // Numerator histogram
271 TH2D* fDenominator; // Denominator histogram
273 //definition of area used for scaling -> Scale is calculated this
274 //way that after division tale is on 1
275 UInt_t fNBinsToScaleX;//number of bins on X axis
276 UInt_t fNBinsToScaleY;//number of bins on Y axis
279 //this must be declared before constructors because they are used as a default arguments
280 static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
281 static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
282 static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
283 static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
284 static const Float_t fgkDefaultMinY;//Default min value of histograms
285 static const Float_t fgkDefaultMaxY;//Default max value of histograms
287 static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
288 static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
290 ClassDef(AliHBTFunction2D,2)
292 /******************************************************************/
293 /******************************************************************/
294 /******************************************************************/
296 //____________________
297 ///////////////////////////////////////////////////////
299 // AliHBTFunction3D //
301 // Base Calss for 3-dimensinal Functions that need //
302 // one pair to fill function //
304 // Piotr.Skowronski@cern.ch //
305 // http://alisoft.cern.ch/people/skowron/analyzer //
307 ///////////////////////////////////////////////////////
309 class AliHBTFunction3D: public AliHBTFunction
314 AliHBTFunction3D(const Char_t *name, const Char_t *title);
316 AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
317 Int_t nYbins, Double_t maxYval, Double_t minYval,
318 Int_t nZbins, Double_t maxZval, Double_t minZval);
320 AliHBTFunction3D(const Char_t *name, const Char_t *title,
321 Int_t nXbins, Double_t maxXval, Double_t minXval,
322 Int_t nYbins, Double_t maxYval, Double_t minYval,
323 Int_t nZbins, Double_t maxZval, Double_t minZval);
325 AliHBTFunction3D(const AliHBTFunction3D & source);
326 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
328 virtual ~AliHBTFunction3D();//destructor
330 TH1* GetNumerator() const {return fNumerator;}
331 TH1* GetDenominator() const {return fDenominator;}
334 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
335 UInt_t yn = fgkDefaultNBinsToScaleY,
336 UInt_t zn = fgkDefaultNBinsToScaleZ);
341 virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
342 Int_t nybins, Float_t ymax, Float_t ymin,
343 Int_t nzbins, Float_t zmax, Float_t zmin);
344 virtual void BuildHistos();
346 TH3F* fNumerator; // Numerator histogram
347 TH3F* fDenominator; // Denominator histogram
349 //definition of area used for scaling -> Scale is calculated this
350 //way that after division tale is on 1
351 UInt_t fNBinsToScaleX;//number of bins on X axis
352 UInt_t fNBinsToScaleY;//number of bins on Y axis
353 UInt_t fNBinsToScaleZ;//number of bins on Z axis
356 //this must be declared before constructors because they are used as a default arguments
357 static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
358 static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
359 static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
360 static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
361 static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
362 static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
363 static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
364 static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
365 static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
367 static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
368 static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
369 static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
371 ClassDef(AliHBTFunction3D,2)
373 /******************************************************************/
374 /******************************************************************/
375 /******************************************************************/
377 //____________________
378 ///////////////////////////////////////////////////////
380 // AliHBTOnePairFctn1D //
382 // Base Calss for 1-dimensinal Functions that need //
383 // one pair to fill function //
385 // Piotr.Skowronski@cern.ch //
386 // http://alisoft.cern.ch/people/skowron/analyzer //
388 ///////////////////////////////////////////////////////
390 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
393 AliHBTOnePairFctn1D(){}//default conmstructor
394 AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
395 AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title);
396 AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
397 Int_t nbins, Float_t maxXval, Float_t minXval);
398 virtual ~AliHBTOnePairFctn1D(){}
400 void ProcessSameEventParticles(AliHBTPair* pair);
401 void ProcessDiffEventParticles(AliHBTPair* pair);
402 void Write(){WriteFunction();}
403 void Init(){InitFunction();}
404 const char* Name(){return GetName();}
407 //retruns velue to be histogrammed
408 virtual Double_t GetValue(AliHBTPair* pair) const = 0;
409 ClassDef(AliHBTOnePairFctn1D,2)
411 /******************************************************************/
412 /******************************************************************/
413 /******************************************************************/
415 //____________________
416 ///////////////////////////////////////////////////////
418 // AliHBTOnePairFctn2D //
420 // Base Calss for 2-dimensinal Functions that need //
421 // one pair to fill function //
423 // Piotr.Skowronski@cern.ch //
424 // http://alisoft.cern.ch/people/skowron/analyzer //
426 ///////////////////////////////////////////////////////
428 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
431 AliHBTOnePairFctn2D(){}
433 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
435 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
436 Int_t nYbins, Double_t maxYval, Double_t minYval);
438 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
439 Int_t nXbins, Double_t maxXval, Double_t minXval,
440 Int_t nYbins, Double_t maxYval, Double_t minYval);
442 virtual ~AliHBTOnePairFctn2D(){}
444 void ProcessSameEventParticles(AliHBTPair* pair);
445 void ProcessDiffEventParticles(AliHBTPair* pair);
446 void Write(){WriteFunction();}
447 void Init(){InitFunction();}
448 const char* Name(){return GetName();}
450 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
451 ClassDef(AliHBTOnePairFctn2D,2)
453 /******************************************************************/
454 /******************************************************************/
455 /******************************************************************/
457 //____________________
458 ///////////////////////////////////////////////////////
460 // AliHBTOnePairFctn3D //
462 // Base Calss for 3-dimensinal Functions that need //
463 // one pair to fill function //
465 // Piotr.Skowronski@cern.ch //
466 // http://alisoft.cern.ch/people/skowron/analyzer //
468 ///////////////////////////////////////////////////////
470 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
473 AliHBTOnePairFctn3D(){}
475 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
477 AliHBTOnePairFctn3D(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);
481 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
482 Int_t nXbins, Double_t maxXval, Double_t minXval,
483 Int_t nYbins, Double_t maxYval, Double_t minYval,
484 Int_t nZbins, Double_t maxZval, Double_t minZval);
486 virtual ~AliHBTOnePairFctn3D(){}//destructor
488 void ProcessSameEventParticles(AliHBTPair* pair);
489 void ProcessDiffEventParticles(AliHBTPair* pair);
490 void Write(){WriteFunction();}
491 void Init(){InitFunction();}
492 const char* Name(){return GetName();}
494 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
495 ClassDef(AliHBTOnePairFctn3D,2)
497 /******************************************************************/
498 /******************************************************************/
499 /******************************************************************/
501 //____________________
502 ///////////////////////////////////////////////////////
504 // AliHBTTwoPairFctn1D //
506 // Base Calss for 1-dimensinal Functions that need //
507 // two pair (simulated and reconstructed) //
508 // to fill function //
510 // Piotr.Skowronski@cern.ch //
511 // http://alisoft.cern.ch/people/skowron/analyzer //
513 ///////////////////////////////////////////////////////
515 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
518 AliHBTTwoPairFctn1D(){}//default conmstructor
519 AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
520 AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
521 AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
522 Int_t nbins, Float_t maxXval, Float_t minXval);
523 virtual ~AliHBTTwoPairFctn1D(){}
525 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
526 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
527 void Write(){WriteFunction();}
528 void Init(){InitFunction();}
529 const char* Name(){return GetName();}
532 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
534 ClassDef(AliHBTTwoPairFctn1D,2)
536 /******************************************************************/
537 /******************************************************************/
538 /******************************************************************/
540 //____________________
541 ///////////////////////////////////////////////////////
543 // AliHBTTwoPairFctn2D //
545 // Base Calss for 2-dimensinal Functions that need //
546 // two pair (simulated and reconstructed) //
547 // to fill function //
549 // Piotr.Skowronski@cern.ch //
550 // http://alisoft.cern.ch/people/skowron/analyzer //
552 ///////////////////////////////////////////////////////
554 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
557 AliHBTTwoPairFctn2D(){}
559 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
561 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
562 Int_t nYbins, Double_t maxYval, Double_t minYval);
564 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
565 Int_t nXbins, Double_t maxXval, Double_t minXval,
566 Int_t nYbins, Double_t maxYval, Double_t minYval);
568 virtual ~AliHBTTwoPairFctn2D(){}
570 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
571 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
572 void Write(){WriteFunction();}
573 void Init(){InitFunction();}
574 const char* Name(){return GetName();}
577 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
579 ClassDef(AliHBTTwoPairFctn2D,2)
581 /******************************************************************/
582 /******************************************************************/
583 /******************************************************************/
585 //____________________
586 ///////////////////////////////////////////////////////
588 // AliHBTTwoPairFctn3D //
590 // Base Calss for 3-dimensinal Functions that need //
591 // two pair (simulated and reconstructed) //
592 // to fill function //
594 // Piotr.Skowronski@cern.ch //
595 // http://alisoft.cern.ch/people/skowron/analyzer //
597 ///////////////////////////////////////////////////////
599 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
602 AliHBTTwoPairFctn3D(){}
604 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
606 AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
607 Int_t nYbins, Double_t maxYval, Double_t minYval,
608 Int_t nZbins, Double_t maxZval, Double_t minZval);
610 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
611 Int_t nXbins, Double_t maxXval, Double_t minXval,
612 Int_t nYbins, Double_t maxYval, Double_t minYval,
613 Int_t nZbins, Double_t maxZval, Double_t minZval);
615 virtual ~AliHBTTwoPairFctn3D(){}//destructor
617 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
618 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
619 void Write(){WriteFunction();}
620 void Init(){InitFunction();}
621 const char* Name(){return GetName();}
624 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
626 ClassDef(AliHBTTwoPairFctn3D,2)