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 /******************************************************************/
80 //____________________
81 ///////////////////////////////////////////////////////
83 // AliHBTOnePairFctn //
85 // Abstract Base Calss for Functions that need //
86 // one pair to fill function //
88 // Piotr.Skowronski@cern.ch //
89 // http://alisoft.cern.ch/people/skowron/analyzer //
91 ///////////////////////////////////////////////////////
93 class AliHBTOnePairFctn
97 virtual ~AliHBTOnePairFctn(){}
99 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
100 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
102 virtual void Init() = 0;
103 virtual void Write() = 0;
105 ClassDef(AliHBTOnePairFctn,2)
107 /******************************************************************/
108 /******************************************************************/
109 /******************************************************************/
111 //____________________
112 ///////////////////////////////////////////////////////
114 // AliHBTTwoPairFctn //
116 // Abstract Base Calss for Functions that need //
117 // two pairs to fill function, //
118 // one reconstructed track and corresponding //
120 // Basically resolution functions //
121 // Lednicky's algorithm uses that as well //
123 // Piotr.Skowronski@cern.ch //
124 // http://alisoft.cern.ch/people/skowron/analyzer //
126 ///////////////////////////////////////////////////////
128 class AliHBTTwoPairFctn
131 AliHBTTwoPairFctn(){};
132 virtual ~AliHBTTwoPairFctn(){};
135 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
137 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
139 virtual void Init() = 0;
140 virtual void Write() = 0;
142 ClassDef(AliHBTTwoPairFctn,2)
145 /******************************************************************/
146 /******************************************************************/
147 /******************************************************************/
149 //____________________
150 ///////////////////////////////////////////////////////
152 // AliHBTFunction1D //
154 // Base Calss for 1-dimensinal Functions //
156 // Piotr.Skowronski@cern.ch //
157 // http://alisoft.cern.ch/people/skowron/analyzer //
159 ///////////////////////////////////////////////////////
162 class AliHBTFunction1D: public AliHBTFunction
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);
171 AliHBTFunction1D(const AliHBTFunction1D & source);
172 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
174 virtual ~AliHBTFunction1D();
176 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
177 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
180 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
183 //returns value to be histogrammed
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);
188 TH1D* fNumerator; // Numerator histogram
189 TH1D* fDenominator; // Denumerator histogram
190 UInt_t fNBinsToScale; // Number of bins to scale
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
199 ClassDef(AliHBTFunction1D,2)
202 /******************************************************************/
203 /******************************************************************/
204 /******************************************************************/
206 //____________________
207 ///////////////////////////////////////////////////////
209 // AliHBTFunction2D //
211 // Base Calss for 2-dimensinal Functions //
213 // Piotr.Skowronski@cern.ch //
214 // http://alisoft.cern.ch/people/skowron/analyzer //
216 ///////////////////////////////////////////////////////
218 class AliHBTFunction2D: public AliHBTFunction
223 AliHBTFunction2D(const Char_t *name, const Char_t *title);
225 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
226 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
232 AliHBTFunction2D(const AliHBTFunction2D & source);
234 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
236 virtual ~AliHBTFunction2D();
238 TH1* GetNumerator() const {return fNumerator;}
239 TH1* GetDenominator() const {return fDenominator;}
241 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
242 UInt_t yn = fgkDefaultNBinsToScaleY);
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();
250 TH2D* fNumerator; // Numerator histogram
251 TH2D* fDenominator; // Denominator histogram
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
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
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
270 ClassDef(AliHBTFunction2D,2)
272 /******************************************************************/
273 /******************************************************************/
274 /******************************************************************/
276 //____________________
277 ///////////////////////////////////////////////////////
279 // AliHBTFunction3D //
281 // Base Calss for 3-dimensinal Functions that need //
282 // one pair to fill function //
284 // Piotr.Skowronski@cern.ch //
285 // http://alisoft.cern.ch/people/skowron/analyzer //
287 ///////////////////////////////////////////////////////
289 class AliHBTFunction3D: public AliHBTFunction
294 AliHBTFunction3D(const Char_t *name, const Char_t *title);
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);
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);
305 AliHBTFunction3D(const AliHBTFunction3D & source);
306 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
308 virtual ~AliHBTFunction3D();//destructor
310 TH1* GetNumerator() const {return fNumerator;}
311 TH1* GetDenominator() const {return fDenominator;}
314 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
315 UInt_t yn = fgkDefaultNBinsToScaleY,
316 UInt_t zn = fgkDefaultNBinsToScaleZ);
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();
326 TH3F* fNumerator; // Numerator histogram
327 TH3F* fDenominator; // Denominator histogram
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
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
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
351 ClassDef(AliHBTFunction3D,2)
353 /******************************************************************/
354 /******************************************************************/
355 /******************************************************************/
357 //____________________
358 ///////////////////////////////////////////////////////
360 // AliHBTOnePairFctn1D //
362 // Base Calss for 1-dimensinal Functions that need //
363 // one pair to fill function //
365 // Piotr.Skowronski@cern.ch //
366 // http://alisoft.cern.ch/people/skowron/analyzer //
368 ///////////////////////////////////////////////////////
370 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
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(){}
380 void ProcessSameEventParticles(AliHBTPair* pair);
381 void ProcessDiffEventParticles(AliHBTPair* pair);
382 void Write(){WriteFunction();}
383 void Init(){InitFunction();}
385 //retruns velue to be histogrammed
386 virtual Double_t GetValue(AliHBTPair* pair) = 0;
387 ClassDef(AliHBTOnePairFctn1D,2)
389 /******************************************************************/
390 /******************************************************************/
391 /******************************************************************/
393 //____________________
394 ///////////////////////////////////////////////////////
396 // AliHBTOnePairFctn2D //
398 // Base Calss for 2-dimensinal Functions that need //
399 // one pair to fill function //
401 // Piotr.Skowronski@cern.ch //
402 // http://alisoft.cern.ch/people/skowron/analyzer //
404 ///////////////////////////////////////////////////////
406 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
409 AliHBTOnePairFctn2D(){}
411 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
413 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
414 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
420 virtual ~AliHBTOnePairFctn2D(){}
422 void ProcessSameEventParticles(AliHBTPair* pair);
423 void ProcessDiffEventParticles(AliHBTPair* pair);
424 void Write(){WriteFunction();}
425 void Init(){InitFunction();}
427 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) = 0;
428 ClassDef(AliHBTOnePairFctn2D,2)
430 /******************************************************************/
431 /******************************************************************/
432 /******************************************************************/
434 //____________________
435 ///////////////////////////////////////////////////////
437 // AliHBTOnePairFctn3D //
439 // Base Calss for 3-dimensinal Functions that need //
440 // one pair to fill function //
442 // Piotr.Skowronski@cern.ch //
443 // http://alisoft.cern.ch/people/skowron/analyzer //
445 ///////////////////////////////////////////////////////
447 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
450 AliHBTOnePairFctn3D(){}
452 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
463 virtual ~AliHBTOnePairFctn3D(){}//destructor
465 void ProcessSameEventParticles(AliHBTPair* pair);
466 void ProcessDiffEventParticles(AliHBTPair* pair);
467 void Write(){WriteFunction();}
468 void Init(){InitFunction();}
470 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) = 0;
471 ClassDef(AliHBTOnePairFctn3D,2)
473 /******************************************************************/
474 /******************************************************************/
475 /******************************************************************/
477 //____________________
478 ///////////////////////////////////////////////////////
480 // AliHBTTwoPairFctn1D //
482 // Base Calss for 1-dimensinal Functions that need //
483 // two pair (simulated and reconstructed) //
484 // to fill function //
486 // Piotr.Skowronski@cern.ch //
487 // http://alisoft.cern.ch/people/skowron/analyzer //
489 ///////////////////////////////////////////////////////
491 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
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(){}
501 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
502 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
503 void Write(){WriteFunction();}
504 void Init(){InitFunction();}
507 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
509 ClassDef(AliHBTTwoPairFctn1D,2)
511 /******************************************************************/
512 /******************************************************************/
513 /******************************************************************/
515 //____________________
516 ///////////////////////////////////////////////////////
518 // AliHBTTwoPairFctn2D //
520 // Base Calss for 2-dimensinal Functions that need //
521 // two pair (simulated and reconstructed) //
522 // to fill function //
524 // Piotr.Skowronski@cern.ch //
525 // http://alisoft.cern.ch/people/skowron/analyzer //
527 ///////////////////////////////////////////////////////
529 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
532 AliHBTTwoPairFctn2D(){}
534 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
536 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
537 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
543 virtual ~AliHBTTwoPairFctn2D(){}
545 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
546 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
547 void Write(){WriteFunction();}
548 void Init(){InitFunction();}
551 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) = 0;
553 ClassDef(AliHBTTwoPairFctn2D,2)
555 /******************************************************************/
556 /******************************************************************/
557 /******************************************************************/
559 //____________________
560 ///////////////////////////////////////////////////////
562 // AliHBTTwoPairFctn3D //
564 // Base Calss for 3-dimensinal Functions that need //
565 // two pair (simulated and reconstructed) //
566 // to fill function //
568 // Piotr.Skowronski@cern.ch //
569 // http://alisoft.cern.ch/people/skowron/analyzer //
571 ///////////////////////////////////////////////////////
573 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
576 AliHBTTwoPairFctn3D(){}
578 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
589 virtual ~AliHBTTwoPairFctn3D(){}//destructor
591 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
592 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
593 void Write(){WriteFunction();}
594 void Init(){InitFunction();}
597 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) = 0;
599 ClassDef(AliHBTTwoPairFctn3D,2)