]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - HBTAN/AliHBTFunction.h
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Redundand if removed
[u/mrichter/AliRoot.git] / HBTAN / AliHBTFunction.h
... / ...
CommitLineData
1#ifndef ALIHBTFUNCTION_H
2#define ALIHBTFUNCTION_H
3
4/* Id: $ */
5
6///////////////////////////////////////////////////////
7// //
8// AliHBTFunction //
9// //
10// Abstract Base Calss for all the function classes //
11// //
12// Piotr.Skowronski@cern.ch //
13// http://alisoft.cern.ch/people/skowron/analyzer //
14// //
15///////////////////////////////////////////////////////
16
17#include <TH1.h>
18#include <TH2D.h>
19#include <TH3D.h>
20
21#include "AliHBTPairCut.h"
22#include "AliHBTPair.h"
23
24
25class AliHBTAnalysis;
26class AliHBTParticleCut;
27
28class AliHBTFunction: public TNamed
29{
30 public:
31 AliHBTFunction();
32 AliHBTFunction(const char* name, const char* title);
33 AliHBTFunction(const AliHBTFunction & source);
34
35 virtual ~AliHBTFunction();
36
37 AliHBTFunction & operator= (const AliHBTFunction & source);
38
39 virtual TH1* GetNumerator() const = 0;
40 virtual TH1* GetDenominator() const = 0;
41 virtual TH1* GetResult() = 0;
42
43 virtual void WriteFunction();
44 virtual void InitFunction();
45
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
49
50 void SetPairCut(AliHBTPairCut* cut);
51
52 virtual AliHBTPair* CheckPair(AliHBTPair* pair);
53
54 protected:
55 virtual void BuildHistos() = 0;//builds default histograms
56 AliHBTPairCut* fPairCut; //pair cut
57
58 ClassDef(AliHBTFunction,2)
59};
60/******************************************************************/
61inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
62{
63 //check if pair and both particles meets the cut criteria
64 if(fPairCut->Pass(pair)) //if the pair is BAD
65 {//it is BAD
66 pair = pair->GetSwapedPair();
67 if(pair)
68 if(fPairCut->Pass(pair)) //so try reverse combination
69 {
70 return 0x0;//it is BAD as well - so return
71 }
72 }
73 return pair;
74}
75
76/******************************************************************/
77/******************************************************************/
78/******************************************************************/
79
80//____________________
81///////////////////////////////////////////////////////
82// //
83// AliHBTOnePairFctn //
84// //
85// Abstract Base Calss for Functions that need //
86// one pair to fill function //
87// //
88// Piotr.Skowronski@cern.ch //
89// http://alisoft.cern.ch/people/skowron/analyzer //
90// //
91///////////////////////////////////////////////////////
92
93class AliHBTOnePairFctn
94{
95 public:
96 AliHBTOnePairFctn(){}
97 virtual ~AliHBTOnePairFctn(){}
98
99 virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
100 virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
101
102 virtual void Init() = 0;
103 virtual void Write() = 0;
104
105 ClassDef(AliHBTOnePairFctn,2)
106};
107/******************************************************************/
108/******************************************************************/
109/******************************************************************/
110
111//____________________
112///////////////////////////////////////////////////////
113// //
114// AliHBTTwoPairFctn //
115// //
116// Abstract Base Calss for Functions that need //
117// two pairs to fill function, //
118// one reconstructed track and corresponding //
119// simulated pair //
120// Basically resolution functions //
121// Lednicky's algorithm uses that as well //
122// //
123// Piotr.Skowronski@cern.ch //
124// http://alisoft.cern.ch/people/skowron/analyzer //
125// //
126///////////////////////////////////////////////////////
127
128class AliHBTTwoPairFctn
129{
130 public:
131 AliHBTTwoPairFctn(){};
132 virtual ~AliHBTTwoPairFctn(){};
133
134 virtual void
135 ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
136 virtual void
137 ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
138
139 virtual void Init() = 0;
140 virtual void Write() = 0;
141
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
162class AliHBTFunction1D: public AliHBTFunction
163{
164 public:
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);
170
171 AliHBTFunction1D(const AliHBTFunction1D & source);
172 AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
173
174 virtual ~AliHBTFunction1D();
175
176 TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
177 TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
178
179 Double_t Scale();
180 void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
181
182 protected:
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);
187
188 TH1D* fNumerator; // Numerator histogram
189 TH1D* fDenominator; // Denumerator histogram
190 UInt_t fNBinsToScale; // Number of bins to scale
191
192 private:
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
198
199 ClassDef(AliHBTFunction1D,2)
200};
201
202/******************************************************************/
203/******************************************************************/
204/******************************************************************/
205
206//____________________
207///////////////////////////////////////////////////////
208// //
209// AliHBTFunction2D //
210// //
211// Base Calss for 2-dimensinal Functions //
212// //
213// Piotr.Skowronski@cern.ch //
214// http://alisoft.cern.ch/people/skowron/analyzer //
215// //
216///////////////////////////////////////////////////////
217
218class AliHBTFunction2D: public AliHBTFunction
219{
220 public:
221 AliHBTFunction2D();
222
223 AliHBTFunction2D(const Char_t *name, const Char_t *title);
224
225 AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
226 Int_t nYbins, Double_t maxYval, Double_t minYval);
227
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);
231
232 AliHBTFunction2D(const AliHBTFunction2D & source);
233
234 AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
235
236 virtual ~AliHBTFunction2D();
237
238 TH1* GetNumerator() const {return fNumerator;}
239 TH1* GetDenominator() const {return fDenominator;}
240
241 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
242 UInt_t yn = fgkDefaultNBinsToScaleY);
243
244 Double_t Scale();
245 protected:
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();
249
250 TH2D* fNumerator; // Numerator histogram
251 TH2D* fDenominator; // Denominator histogram
252
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
257
258 private:
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
266
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
269
270 ClassDef(AliHBTFunction2D,2)
271};
272/******************************************************************/
273/******************************************************************/
274/******************************************************************/
275
276//____________________
277///////////////////////////////////////////////////////
278// //
279// AliHBTFunction3D //
280// //
281// Base Calss for 3-dimensinal Functions that need //
282// one pair to fill function //
283// //
284// Piotr.Skowronski@cern.ch //
285// http://alisoft.cern.ch/people/skowron/analyzer //
286// //
287///////////////////////////////////////////////////////
288
289class AliHBTFunction3D: public AliHBTFunction
290{
291 public:
292 AliHBTFunction3D();
293
294 AliHBTFunction3D(const Char_t *name, const Char_t *title);
295
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);
299
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);
304
305 AliHBTFunction3D(const AliHBTFunction3D & source);
306 AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
307
308 virtual ~AliHBTFunction3D();//destructor
309
310 TH1* GetNumerator() const {return fNumerator;}
311 TH1* GetDenominator() const {return fDenominator;}
312
313
314 void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
315 UInt_t yn = fgkDefaultNBinsToScaleY,
316 UInt_t zn = fgkDefaultNBinsToScaleZ);
317
318 Double_t Scale();
319
320 protected:
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();
325
326 TH3D* fNumerator; // Numerator histogram
327 TH3D* fDenominator; // Denominator histogram
328
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
334
335 private:
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
346
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
350
351 ClassDef(AliHBTFunction3D,2)
352};
353/******************************************************************/
354/******************************************************************/
355/******************************************************************/
356
357//____________________
358///////////////////////////////////////////////////////
359// //
360// AliHBTOnePairFctn1D //
361// //
362// Base Calss for 1-dimensinal Functions that need //
363// one pair to fill function //
364// //
365// Piotr.Skowronski@cern.ch //
366// http://alisoft.cern.ch/people/skowron/analyzer //
367// //
368///////////////////////////////////////////////////////
369
370class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
371{
372 public:
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(){}
379
380 void ProcessSameEventParticles(AliHBTPair* pair);
381 void ProcessDiffEventParticles(AliHBTPair* pair);
382 void Write(){WriteFunction();}
383 void Init(){InitFunction();}
384 protected:
385 //retruns velue to be histogrammed
386 virtual Double_t GetValue(AliHBTPair* pair) = 0;
387 ClassDef(AliHBTOnePairFctn1D,2)
388};
389/******************************************************************/
390/******************************************************************/
391/******************************************************************/
392
393//____________________
394///////////////////////////////////////////////////////
395// //
396// AliHBTOnePairFctn2D //
397// //
398// Base Calss for 2-dimensinal Functions that need //
399// one pair to fill function //
400// //
401// Piotr.Skowronski@cern.ch //
402// http://alisoft.cern.ch/people/skowron/analyzer //
403// //
404///////////////////////////////////////////////////////
405
406class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
407{
408 public:
409 AliHBTOnePairFctn2D(){}
410
411 AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
412
413 AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
414 Int_t nYbins, Double_t maxYval, Double_t minYval);
415
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);
419
420 virtual ~AliHBTOnePairFctn2D(){}
421
422 void ProcessSameEventParticles(AliHBTPair* pair);
423 void ProcessDiffEventParticles(AliHBTPair* pair);
424 void Write(){WriteFunction();}
425 void Init(){InitFunction();}
426 protected:
427 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) = 0;
428 ClassDef(AliHBTOnePairFctn2D,2)
429};
430/******************************************************************/
431/******************************************************************/
432/******************************************************************/
433
434//____________________
435///////////////////////////////////////////////////////
436// //
437// AliHBTOnePairFctn3D //
438// //
439// Base Calss for 3-dimensinal Functions that need //
440// one pair to fill function //
441// //
442// Piotr.Skowronski@cern.ch //
443// http://alisoft.cern.ch/people/skowron/analyzer //
444// //
445///////////////////////////////////////////////////////
446
447class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
448{
449 public:
450 AliHBTOnePairFctn3D(){}
451
452 AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
453
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);
457
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);
462
463 virtual ~AliHBTOnePairFctn3D(){}//destructor
464
465 void ProcessSameEventParticles(AliHBTPair* pair);
466 void ProcessDiffEventParticles(AliHBTPair* pair);
467 void Write(){WriteFunction();}
468 void Init(){InitFunction();}
469 protected:
470 virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) = 0;
471 ClassDef(AliHBTOnePairFctn3D,2)
472};
473/******************************************************************/
474/******************************************************************/
475/******************************************************************/
476
477//____________________
478///////////////////////////////////////////////////////
479// //
480// AliHBTTwoPairFctn1D //
481// //
482// Base Calss for 1-dimensinal Functions that need //
483// two pair (simulated and reconstructed) //
484// to fill function //
485// //
486// Piotr.Skowronski@cern.ch //
487// http://alisoft.cern.ch/people/skowron/analyzer //
488// //
489///////////////////////////////////////////////////////
490
491class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
492{
493 public:
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(){}
500
501 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
502 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
503 void Write(){WriteFunction();}
504 void Init(){InitFunction();}
505
506 protected:
507 virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
508
509 ClassDef(AliHBTTwoPairFctn1D,2)
510};
511/******************************************************************/
512/******************************************************************/
513/******************************************************************/
514
515//____________________
516///////////////////////////////////////////////////////
517// //
518// AliHBTTwoPairFctn2D //
519// //
520// Base Calss for 2-dimensinal Functions that need //
521// two pair (simulated and reconstructed) //
522// to fill function //
523// //
524// Piotr.Skowronski@cern.ch //
525// http://alisoft.cern.ch/people/skowron/analyzer //
526// //
527///////////////////////////////////////////////////////
528
529class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
530{
531 public:
532 AliHBTTwoPairFctn2D(){}
533
534 AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
535
536 AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
537 Int_t nYbins, Double_t maxYval, Double_t minYval);
538
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);
542
543 virtual ~AliHBTTwoPairFctn2D(){}
544
545 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
546 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
547 void Write(){WriteFunction();}
548 void Init(){InitFunction();}
549
550 protected:
551 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) = 0;
552
553 ClassDef(AliHBTTwoPairFctn2D,2)
554};
555/******************************************************************/
556/******************************************************************/
557/******************************************************************/
558
559//____________________
560///////////////////////////////////////////////////////
561// //
562// AliHBTTwoPairFctn3D //
563// //
564// Base Calss for 3-dimensinal Functions that need //
565// two pair (simulated and reconstructed) //
566// to fill function //
567// //
568// Piotr.Skowronski@cern.ch //
569// http://alisoft.cern.ch/people/skowron/analyzer //
570// //
571///////////////////////////////////////////////////////
572
573class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
574{
575 public:
576 AliHBTTwoPairFctn3D(){}
577
578 AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
579
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);
583
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);
588
589 virtual ~AliHBTTwoPairFctn3D(){}//destructor
590
591 void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
592 void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
593 void Write(){WriteFunction();}
594 void Init(){InitFunction();}
595
596 protected:
597 virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) = 0;
598
599 ClassDef(AliHBTTwoPairFctn3D,2)
600};
601
602#endif