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