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 "AliAODPairCut.h"
22 #include "AliHBTPair.h"
26 class AliVAODParticleCut;
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(AliAODPairCut* 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 AliAODPairCut* 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->Rejected(pair)) return 0x0; //if the pair is BAD
66 // It is not allowed to change the order here beacause analysis enforce the order
69 // pair = pair->GetSwappedPair();
71 // if(fPairCut->Rejected(pair)) //so try reverse combination
73 // return 0x0;//it is BAD as well - so return
80 /******************************************************************/
81 /******************************************************************/
82 /******************************************************************/
83 class AliHBTCorrelFunction
86 AliHBTCorrelFunction():fRatio(0x0){}
87 AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
88 virtual ~AliHBTCorrelFunction(){delete fRatio;}
90 AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
93 TH1* fRatio;//!pointer to the ratio(result)
95 ClassDef(AliHBTCorrelFunction,1)
98 /******************************************************************/
99 /******************************************************************/
100 /******************************************************************/
102 //____________________
103 ///////////////////////////////////////////////////////
105 // AliHBTOnePairFctn //
107 // Abstract Base Calss for Functions that need //
108 // one pair to fill function //
110 // Piotr.Skowronski@cern.ch //
111 // http://alisoft.cern.ch/people/skowron/analyzer //
113 ///////////////////////////////////////////////////////
115 class AliHBTOnePairFctn
118 AliHBTOnePairFctn(){}
119 virtual ~AliHBTOnePairFctn(){}
121 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
122 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
124 virtual void Init() = 0;
125 virtual void Write() = 0;
126 virtual const char* Name() = 0;
128 ClassDef(AliHBTOnePairFctn,2)
130 /******************************************************************/
131 /******************************************************************/
132 /******************************************************************/
134 //____________________
135 ///////////////////////////////////////////////////////
137 // AliHBTTwoPairFctn //
139 // Abstract Base Calss for Functions that need //
140 // two pairs to fill function, //
141 // one reconstructed track and corresponding //
143 // Basically resolution functions //
144 // Lednicky's algorithm uses that as well //
146 // Piotr.Skowronski@cern.ch //
147 // http://alisoft.cern.ch/people/skowron/analyzer //
149 ///////////////////////////////////////////////////////
151 class AliHBTTwoPairFctn
154 AliHBTTwoPairFctn(){};
155 virtual ~AliHBTTwoPairFctn(){};
158 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
160 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
162 virtual void Init() = 0;
163 virtual void Write() = 0;
164 virtual const char* Name() = 0;
166 ClassDef(AliHBTTwoPairFctn,2)
169 /******************************************************************/
170 /******************************************************************/
171 /******************************************************************/
173 //____________________
174 ///////////////////////////////////////////////////////
176 // AliHBTFunction1D //
178 // Base Calss for 1-dimensinal Functions //
180 // Piotr.Skowronski@cern.ch //
181 // http://alisoft.cern.ch/people/skowron/analyzer //
183 ///////////////////////////////////////////////////////
186 class AliHBTFunction1D: public AliHBTFunction
189 AliHBTFunction1D();//default conmstructor
190 AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
191 AliHBTFunction1D(const Char_t *name, const Char_t *title);
192 AliHBTFunction1D(const Char_t *name, const Char_t *title,
193 Int_t nbins, Float_t maxXval, Float_t minXval);
195 AliHBTFunction1D(const AliHBTFunction1D & source);
196 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
198 virtual ~AliHBTFunction1D();
200 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
201 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
204 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
207 //returns value to be histogrammed
208 virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
209 virtual void BuildHistos();
210 Double_t Scale(TH1D* num,TH1D* den);
212 TH1D* fNumerator; // Numerator histogram
213 TH1D* fDenominator; // Denumerator histogram
214 UInt_t fNBinsToScale; // Number of bins to scale
217 //this must be declared before constructors because they are used as a default arguments
218 static const Int_t fgkDefaultNBins;//default number of Bins in histograms
219 static const Float_t fgkDefaultMin;//Default min value of histograms
220 static const Float_t fgkDefaultMax;//Default max value of histograms
221 static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
223 ClassDef(AliHBTFunction1D,2)
226 /******************************************************************/
227 /******************************************************************/
228 /******************************************************************/
230 //____________________
231 ///////////////////////////////////////////////////////
233 // AliHBTFunction2D //
235 // Base Calss for 2-dimensinal Functions //
237 // Piotr.Skowronski@cern.ch //
238 // http://alisoft.cern.ch/people/skowron/analyzer //
240 ///////////////////////////////////////////////////////
242 class AliHBTFunction2D: public AliHBTFunction
247 AliHBTFunction2D(const Char_t *name, const Char_t *title);
249 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
250 Int_t nYbins, Double_t maxYval, Double_t minYval);
252 AliHBTFunction2D(const Char_t *name, const Char_t *title,
253 Int_t nXbins, Double_t maxXval, Double_t minXval,
254 Int_t nYbins, Double_t maxYval, Double_t minYval);
256 AliHBTFunction2D(const AliHBTFunction2D & source);
258 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
260 virtual ~AliHBTFunction2D();
262 TH1* GetNumerator() const {return fNumerator;}
263 TH1* GetDenominator() const {return fDenominator;}
265 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
266 UInt_t yn = fgkDefaultNBinsToScaleY);
270 virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
271 Int_t nybins, Float_t ymax, Float_t ymin);
272 virtual void BuildHistos();
274 TH2D* fNumerator; // Numerator histogram
275 TH2D* fDenominator; // Denominator histogram
277 //definition of area used for scaling -> Scale is calculated this
278 //way that after division tale is on 1
279 UInt_t fNBinsToScaleX;//number of bins on X axis
280 UInt_t fNBinsToScaleY;//number of bins on Y axis
283 //this must be declared before constructors because they are used as a default arguments
284 static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
285 static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
286 static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
287 static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
288 static const Float_t fgkDefaultMinY;//Default min value of histograms
289 static const Float_t fgkDefaultMaxY;//Default max value of histograms
291 static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
292 static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
294 ClassDef(AliHBTFunction2D,2)
296 /******************************************************************/
297 /******************************************************************/
298 /******************************************************************/
300 //____________________
301 ///////////////////////////////////////////////////////
303 // AliHBTFunction3D //
305 // Base Calss for 3-dimensinal Functions that need //
306 // one pair to fill function //
308 // Piotr.Skowronski@cern.ch //
309 // http://alisoft.cern.ch/people/skowron/analyzer //
311 ///////////////////////////////////////////////////////
313 class AliHBTFunction3D: public AliHBTFunction
318 AliHBTFunction3D(const Char_t *name, const Char_t *title);
320 AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
321 Int_t nYbins, Double_t maxYval, Double_t minYval,
322 Int_t nZbins, Double_t maxZval, Double_t minZval);
324 AliHBTFunction3D(const Char_t *name, const Char_t *title,
325 Int_t nXbins, Double_t maxXval, Double_t minXval,
326 Int_t nYbins, Double_t maxYval, Double_t minYval,
327 Int_t nZbins, Double_t maxZval, Double_t minZval);
329 AliHBTFunction3D(const AliHBTFunction3D & source);
330 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
332 virtual ~AliHBTFunction3D();//destructor
334 TH1* GetNumerator() const {return fNumerator;}
335 TH1* GetDenominator() const {return fDenominator;}
338 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
339 UInt_t yn = fgkDefaultNBinsToScaleY,
340 UInt_t zn = fgkDefaultNBinsToScaleZ);
345 virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
346 Int_t nybins, Float_t ymax, Float_t ymin,
347 Int_t nzbins, Float_t zmax, Float_t zmin);
348 virtual void BuildHistos();
350 TH3F* fNumerator; // Numerator histogram
351 TH3F* fDenominator; // Denominator histogram
353 //definition of area used for scaling -> Scale is calculated this
354 //way that after division tale is on 1
355 UInt_t fNBinsToScaleX;//number of bins on X axis
356 UInt_t fNBinsToScaleY;//number of bins on Y axis
357 UInt_t fNBinsToScaleZ;//number of bins on Z axis
360 //this must be declared before constructors because they are used as a default arguments
361 static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
362 static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
363 static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
364 static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
365 static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
366 static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
367 static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
368 static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
369 static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
371 static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
372 static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
373 static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
375 ClassDef(AliHBTFunction3D,2)
377 /******************************************************************/
378 /******************************************************************/
379 /******************************************************************/
381 //____________________
382 ///////////////////////////////////////////////////////
384 // AliHBTOnePairFctn1D //
386 // Base Calss for 1-dimensinal Functions that need //
387 // one pair to fill function //
389 // Piotr.Skowronski@cern.ch //
390 // http://alisoft.cern.ch/people/skowron/analyzer //
392 ///////////////////////////////////////////////////////
394 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
397 AliHBTOnePairFctn1D(){}//default conmstructor
398 AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
399 AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title);
400 AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
401 Int_t nbins, Float_t maxXval, Float_t minXval);
402 virtual ~AliHBTOnePairFctn1D(){}
404 void ProcessSameEventParticles(AliHBTPair* pair);
405 void ProcessDiffEventParticles(AliHBTPair* pair);
406 void Write(){WriteFunction();}
407 void Init(){InitFunction();}
408 const char* Name(){return GetName();}
411 //retruns velue to be histogrammed
412 virtual Double_t GetValue(AliHBTPair* pair) const = 0;
413 ClassDef(AliHBTOnePairFctn1D,2)
415 /******************************************************************/
416 /******************************************************************/
417 /******************************************************************/
419 //____________________
420 ///////////////////////////////////////////////////////
422 // AliHBTOnePairFctn2D //
424 // Base Calss for 2-dimensinal Functions that need //
425 // one pair to fill function //
427 // Piotr.Skowronski@cern.ch //
428 // http://alisoft.cern.ch/people/skowron/analyzer //
430 ///////////////////////////////////////////////////////
432 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
435 AliHBTOnePairFctn2D(){}
437 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
439 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
440 Int_t nYbins, Double_t maxYval, Double_t minYval);
442 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
443 Int_t nXbins, Double_t maxXval, Double_t minXval,
444 Int_t nYbins, Double_t maxYval, Double_t minYval);
446 virtual ~AliHBTOnePairFctn2D(){}
448 void ProcessSameEventParticles(AliHBTPair* pair);
449 void ProcessDiffEventParticles(AliHBTPair* pair);
450 void Write(){WriteFunction();}
451 void Init(){InitFunction();}
452 const char* Name(){return GetName();}
454 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
455 ClassDef(AliHBTOnePairFctn2D,2)
457 /******************************************************************/
458 /******************************************************************/
459 /******************************************************************/
461 //____________________
462 ///////////////////////////////////////////////////////
464 // AliHBTOnePairFctn3D //
466 // Base Calss for 3-dimensinal Functions that need //
467 // one pair to fill function //
469 // Piotr.Skowronski@cern.ch //
470 // http://alisoft.cern.ch/people/skowron/analyzer //
472 ///////////////////////////////////////////////////////
474 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
477 AliHBTOnePairFctn3D(){}
479 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
481 AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
482 Int_t nYbins, Double_t maxYval, Double_t minYval,
483 Int_t nZbins, Double_t maxZval, Double_t minZval);
485 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
486 Int_t nXbins, Double_t maxXval, Double_t minXval,
487 Int_t nYbins, Double_t maxYval, Double_t minYval,
488 Int_t nZbins, Double_t maxZval, Double_t minZval);
490 virtual ~AliHBTOnePairFctn3D(){}//destructor
492 void ProcessSameEventParticles(AliHBTPair* pair);
493 void ProcessDiffEventParticles(AliHBTPair* pair);
494 void Write(){WriteFunction();}
495 void Init(){InitFunction();}
496 const char* Name(){return GetName();}
498 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
499 ClassDef(AliHBTOnePairFctn3D,2)
501 /******************************************************************/
502 /******************************************************************/
503 /******************************************************************/
505 //____________________
506 ///////////////////////////////////////////////////////
508 // AliHBTTwoPairFctn1D //
510 // Base Calss for 1-dimensinal Functions that need //
511 // two pair (simulated and reconstructed) //
512 // to fill function //
514 // Piotr.Skowronski@cern.ch //
515 // http://alisoft.cern.ch/people/skowron/analyzer //
517 ///////////////////////////////////////////////////////
519 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
522 AliHBTTwoPairFctn1D(){}//default conmstructor
523 AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
524 AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
525 AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
526 Int_t nbins, Float_t maxXval, Float_t minXval);
527 virtual ~AliHBTTwoPairFctn1D(){}
529 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
530 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
531 void Write(){WriteFunction();}
532 void Init(){InitFunction();}
533 const char* Name(){return GetName();}
536 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
538 ClassDef(AliHBTTwoPairFctn1D,2)
540 /******************************************************************/
541 /******************************************************************/
542 /******************************************************************/
544 //____________________
545 ///////////////////////////////////////////////////////
547 // AliHBTTwoPairFctn2D //
549 // Base Calss for 2-dimensinal Functions that need //
550 // two pair (simulated and reconstructed) //
551 // to fill function //
553 // Piotr.Skowronski@cern.ch //
554 // http://alisoft.cern.ch/people/skowron/analyzer //
556 ///////////////////////////////////////////////////////
558 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
561 AliHBTTwoPairFctn2D(){}
563 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
565 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
566 Int_t nYbins, Double_t maxYval, Double_t minYval);
568 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
569 Int_t nXbins, Double_t maxXval, Double_t minXval,
570 Int_t nYbins, Double_t maxYval, Double_t minYval);
572 virtual ~AliHBTTwoPairFctn2D(){}
574 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
575 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
576 void Write(){WriteFunction();}
577 void Init(){InitFunction();}
578 const char* Name(){return GetName();}
581 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
583 ClassDef(AliHBTTwoPairFctn2D,2)
585 /******************************************************************/
586 /******************************************************************/
587 /******************************************************************/
589 //____________________
590 ///////////////////////////////////////////////////////
592 // AliHBTTwoPairFctn3D //
594 // Base Calss for 3-dimensinal Functions that need //
595 // two pair (simulated and reconstructed) //
596 // to fill function //
598 // Piotr.Skowronski@cern.ch //
599 // http://alisoft.cern.ch/people/skowron/analyzer //
601 ///////////////////////////////////////////////////////
603 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
606 AliHBTTwoPairFctn3D(){}
608 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
610 AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
611 Int_t nYbins, Double_t maxYval, Double_t minYval,
612 Int_t nZbins, Double_t maxZval, Double_t minZval);
614 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
615 Int_t nXbins, Double_t maxXval, Double_t minXval,
616 Int_t nYbins, Double_t maxYval, Double_t minYval,
617 Int_t nZbins, Double_t maxZval, Double_t minZval);
619 virtual ~AliHBTTwoPairFctn3D(){}//destructor
621 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
622 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
623 void Write(){WriteFunction();}
624 void Init(){InitFunction();}
625 const char* Name(){return GetName();}
628 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
630 ClassDef(AliHBTTwoPairFctn3D,2)