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://aliweb.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 Int_t 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);
51 void UseAbsoluteValues(Bool_t flag){fAbs = flag;}
53 virtual AliHBTPair* CheckPair(AliHBTPair* pair);
54 void SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
56 virtual void BuildHistos() = 0;//builds default histograms
57 AliAODPairCut* fPairCut; //pair cut
58 Bool_t fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
59 Bool_t fAbs;//flag indicating if absolute values of qout, qside and qlong should be histogrammed
61 ClassDef(AliHBTFunction,3)
63 /******************************************************************/
64 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
66 //check if pair and both particles meets the cut criteria
67 if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
69 // It is not allowed to change the order here beacause analysis enforce the order
72 // pair = pair->GetSwappedPair();
74 // if(fPairCut->Rejected(pair)) //so try reverse combination
76 // return 0x0;//it is BAD as well - so return
83 /******************************************************************/
84 /******************************************************************/
85 /******************************************************************/
86 class AliHBTCorrelFunction
89 AliHBTCorrelFunction():fRatio(0x0){}
90 AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
91 virtual ~AliHBTCorrelFunction(){delete fRatio;}
93 AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
96 TH1* fRatio;//!pointer to the ratio(result)
98 ClassDef(AliHBTCorrelFunction,1)
101 /******************************************************************/
102 /******************************************************************/
103 /******************************************************************/
105 //____________________
106 ///////////////////////////////////////////////////////
108 // AliHBTOnePairFctn //
110 // Abstract Base Calss for Functions that need //
111 // one pair to fill function //
113 // Piotr.Skowronski@cern.ch //
114 // http://aliweb.cern.ch/people/skowron/analyzer //
116 ///////////////////////////////////////////////////////
118 class AliHBTOnePairFctn
121 AliHBTOnePairFctn(){}
122 virtual ~AliHBTOnePairFctn(){}
124 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
125 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
127 virtual void Init() = 0;
128 virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
129 virtual const char* Name() = 0;
131 ClassDef(AliHBTOnePairFctn,2)
133 /******************************************************************/
134 /******************************************************************/
135 /******************************************************************/
137 //____________________
138 ///////////////////////////////////////////////////////
140 // AliHBTTwoPairFctn //
142 // Abstract Base Calss for Functions that need //
143 // two pairs to fill function, //
144 // one reconstructed track and corresponding //
146 // Basically resolution functions //
147 // Lednicky's algorithm uses that as well //
149 // Piotr.Skowronski@cern.ch //
150 // http://aliweb.cern.ch/people/skowron/analyzer //
152 ///////////////////////////////////////////////////////
154 class AliHBTTwoPairFctn
157 AliHBTTwoPairFctn(){};
158 virtual ~AliHBTTwoPairFctn(){};
161 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
163 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
165 virtual void Init() = 0;
166 virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
167 virtual const char* Name() = 0;
169 ClassDef(AliHBTTwoPairFctn,2)
172 /******************************************************************/
173 /******************************************************************/
174 /******************************************************************/
176 //____________________
177 ///////////////////////////////////////////////////////
179 // AliHBTFunction1D //
181 // Base Calss for 1-dimensinal Functions //
183 // Piotr.Skowronski@cern.ch //
184 // http://aliweb.cern.ch/people/skowron/analyzer //
186 ///////////////////////////////////////////////////////
189 class AliHBTFunction1D: public AliHBTFunction
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);
198 AliHBTFunction1D(const AliHBTFunction1D & source);
199 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
201 virtual ~AliHBTFunction1D();
203 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
204 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
207 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
210 //returns value to be histogrammed
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);
215 TH1D* fNumerator; // Numerator histogram
216 TH1D* fDenominator; // Denumerator histogram
217 UInt_t fNBinsToScale; // Number of bins to scale
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
226 ClassDef(AliHBTFunction1D,2)
229 /******************************************************************/
230 /******************************************************************/
231 /******************************************************************/
233 //____________________
234 ///////////////////////////////////////////////////////
236 // AliHBTFunction2D //
238 // Base Calss for 2-dimensinal Functions //
240 // Piotr.Skowronski@cern.ch //
241 // http://aliweb.cern.ch/people/skowron/analyzer //
243 ///////////////////////////////////////////////////////
245 class AliHBTFunction2D: public AliHBTFunction
250 AliHBTFunction2D(const Char_t *name, const Char_t *title);
252 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
253 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
259 AliHBTFunction2D(const AliHBTFunction2D & source);
261 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
263 virtual ~AliHBTFunction2D();
265 TH1* GetNumerator() const {return fNumerator;}
266 TH1* GetDenominator() const {return fDenominator;}
268 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
269 UInt_t yn = fgkDefaultNBinsToScaleY);
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();
277 TH2D* fNumerator; // Numerator histogram
278 TH2D* fDenominator; // Denominator histogram
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
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
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
297 ClassDef(AliHBTFunction2D,2)
299 /******************************************************************/
300 /******************************************************************/
301 /******************************************************************/
303 //____________________
304 ///////////////////////////////////////////////////////
306 // AliHBTFunction3D //
308 // Base Calss for 3-dimensinal Functions that need //
309 // one pair to fill function //
311 // Piotr.Skowronski@cern.ch //
312 // http://aliweb.cern.ch/people/skowron/analyzer //
314 ///////////////////////////////////////////////////////
316 class AliHBTFunction3D: public AliHBTFunction
321 AliHBTFunction3D(const Char_t *name, const Char_t *title);
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);
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);
332 AliHBTFunction3D(const AliHBTFunction3D & source);
333 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
335 virtual ~AliHBTFunction3D();//destructor
337 TH1* GetNumerator() const {return fNumerator;}
338 TH1* GetDenominator() const {return fDenominator;}
341 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
342 UInt_t yn = fgkDefaultNBinsToScaleY,
343 UInt_t zn = fgkDefaultNBinsToScaleZ);
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();
353 TH3F* fNumerator; // Numerator histogram
354 TH3F* fDenominator; // Denominator histogram
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
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
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
378 ClassDef(AliHBTFunction3D,2)
380 /******************************************************************/
381 /******************************************************************/
382 /******************************************************************/
384 //____________________
385 ///////////////////////////////////////////////////////
387 // AliHBTOnePairFctn1D //
389 // Base Calss for 1-dimensinal Functions that need //
390 // one pair to fill function //
392 // Piotr.Skowronski@cern.ch //
393 // http://aliweb.cern.ch/people/skowron/analyzer //
395 ///////////////////////////////////////////////////////
397 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
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(){}
407 void ProcessSameEventParticles(AliHBTPair* pair);
408 void ProcessDiffEventParticles(AliHBTPair* pair);
409 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
410 void Init(){InitFunction();}
411 const char* Name(){return GetName();}
414 //retruns velue to be histogrammed
415 virtual Double_t GetValue(AliHBTPair* pair) const = 0;
416 ClassDef(AliHBTOnePairFctn1D,2)
418 /******************************************************************/
419 /******************************************************************/
420 /******************************************************************/
422 //____________________
423 ///////////////////////////////////////////////////////
425 // AliHBTOnePairFctn2D //
427 // Base Calss for 2-dimensinal Functions that need //
428 // one pair to fill function //
430 // Piotr.Skowronski@cern.ch //
431 // http://aliweb.cern.ch/people/skowron/analyzer //
433 ///////////////////////////////////////////////////////
435 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
438 AliHBTOnePairFctn2D(){}
440 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
442 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
443 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
449 virtual ~AliHBTOnePairFctn2D(){}
451 void ProcessSameEventParticles(AliHBTPair* pair);
452 void ProcessDiffEventParticles(AliHBTPair* pair);
453 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
454 void Init(){InitFunction();}
455 const char* Name(){return GetName();}
457 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
458 ClassDef(AliHBTOnePairFctn2D,2)
460 /******************************************************************/
461 /******************************************************************/
462 /******************************************************************/
464 //____________________
465 ///////////////////////////////////////////////////////
467 // AliHBTOnePairFctn3D //
469 // Base Calss for 3-dimensinal Functions that need //
470 // one pair to fill function //
472 // Piotr.Skowronski@cern.ch //
473 // http://aliweb.cern.ch/people/skowron/analyzer //
475 ///////////////////////////////////////////////////////
477 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
480 AliHBTOnePairFctn3D(){}
482 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
493 virtual ~AliHBTOnePairFctn3D(){}//destructor
495 void ProcessSameEventParticles(AliHBTPair* pair);
496 void ProcessDiffEventParticles(AliHBTPair* pair);
497 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
498 void Init(){InitFunction();}
499 const char* Name(){return GetName();}
501 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
502 ClassDef(AliHBTOnePairFctn3D,2)
504 /******************************************************************/
505 /******************************************************************/
506 /******************************************************************/
508 //____________________
509 ///////////////////////////////////////////////////////
511 // AliHBTTwoPairFctn1D //
513 // Base Calss for 1-dimensinal Functions that need //
514 // two pair (simulated and reconstructed) //
515 // to fill function //
517 // Piotr.Skowronski@cern.ch //
518 // http://aliweb.cern.ch/people/skowron/analyzer //
520 ///////////////////////////////////////////////////////
522 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
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(){}
532 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
533 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
534 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
535 void Init(){InitFunction();}
536 const char* Name(){return GetName();}
539 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
541 ClassDef(AliHBTTwoPairFctn1D,2)
543 /******************************************************************/
544 /******************************************************************/
545 /******************************************************************/
547 //____________________
548 ///////////////////////////////////////////////////////
550 // AliHBTTwoPairFctn2D //
552 // Base Calss for 2-dimensinal Functions that need //
553 // two pair (simulated and reconstructed) //
554 // to fill function //
556 // Piotr.Skowronski@cern.ch //
557 // http://aliweb.cern.ch/people/skowron/analyzer //
559 ///////////////////////////////////////////////////////
561 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
564 AliHBTTwoPairFctn2D(){}
566 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
568 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
569 Int_t nYbins, Double_t maxYval, Double_t minYval);
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);
575 virtual ~AliHBTTwoPairFctn2D(){}
577 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
578 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
579 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
580 void Init(){InitFunction();}
581 const char* Name(){return GetName();}
584 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
586 ClassDef(AliHBTTwoPairFctn2D,2)
588 /******************************************************************/
589 /******************************************************************/
590 /******************************************************************/
592 //____________________
593 ///////////////////////////////////////////////////////
595 // AliHBTTwoPairFctn3D //
597 // Base Calss for 3-dimensinal Functions that need //
598 // two pair (simulated and reconstructed) //
599 // to fill function //
601 // Piotr.Skowronski@cern.ch //
602 // http://aliweb.cern.ch/people/skowron/analyzer //
604 ///////////////////////////////////////////////////////
606 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
609 AliHBTTwoPairFctn3D(){}
611 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
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);
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);
622 virtual ~AliHBTTwoPairFctn3D(){}//destructor
624 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
625 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
626 Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
627 void Init(){InitFunction();}
628 const char* Name(){return GetName();}
631 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
633 ClassDef(AliHBTTwoPairFctn3D,2)