]>
Commit | Line | Data |
---|---|---|
1b446896 | 1 | #ifndef ALIHBTFUNCTION_H |
2 | #define ALIHBTFUNCTION_H | |
6e8d850a | 3 | |
4 | /* Id: $ */ | |
5 | ||
26f1270c | 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 | ||
2dc7203b | 17 | #include <TH1.h> |
4e4af325 | 18 | #include <TH2D.h> |
19 | #include <TH3D.h> | |
2dc7203b | 20 | |
78d7c6d3 | 21 | #include "AliAODPairCut.h" |
2dc7203b | 22 | #include "AliHBTPair.h" |
23 | ||
2dc7203b | 24 | |
25 | class AliHBTAnalysis; | |
78d7c6d3 | 26 | class AliVAODParticleCut; |
2dc7203b | 27 | |
1b446896 | 28 | class AliHBTFunction: public TNamed |
1b446896 | 29 | { |
30 | public: | |
31 | AliHBTFunction(); | |
28cf76fa | 32 | AliHBTFunction(const char* name, const char* title); |
33 | AliHBTFunction(const AliHBTFunction & source); | |
34 | ||
856180e9 | 35 | virtual ~AliHBTFunction(); |
1b446896 | 36 | |
28cf76fa | 37 | AliHBTFunction & operator= (const AliHBTFunction & source); |
6e8d850a | 38 | |
26f1270c | 39 | virtual TH1* GetNumerator() const = 0; |
40 | virtual TH1* GetDenominator() const = 0; | |
1b446896 | 41 | virtual TH1* GetResult() = 0; |
976183fd | 42 | |
c41732dc | 43 | virtual void WriteFunction(); |
44 | virtual void InitFunction(); | |
1b446896 | 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 | ||
78d7c6d3 | 50 | void SetPairCut(AliAODPairCut* cut); |
1b446896 | 51 | |
52 | virtual AliHBTPair* CheckPair(AliHBTPair* pair); | |
e6e21fa2 | 53 | void SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;} |
1b446896 | 54 | protected: |
26f1270c | 55 | virtual void BuildHistos() = 0;//builds default histograms |
78d7c6d3 | 56 | AliAODPairCut* fPairCut; //pair cut |
e6e21fa2 | 57 | Bool_t fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result |
58 | ClassDef(AliHBTFunction,3) | |
1b446896 | 59 | }; |
976183fd | 60 | /******************************************************************/ |
1b446896 | 61 | inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair) |
62 | { | |
63 | //check if pair and both particles meets the cut criteria | |
cea0a066 | 64 | if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD |
7423906b | 65 | |
55d46048 | 66 | // It is not allowed to change the order here beacause analysis enforce the order |
7423906b | 67 | |
68 | // {//it is BAD | |
78d7c6d3 | 69 | // pair = pair->GetSwappedPair(); |
7423906b | 70 | // if(pair) |
cea0a066 | 71 | // if(fPairCut->Rejected(pair)) //so try reverse combination |
7423906b | 72 | // { |
73 | // return 0x0;//it is BAD as well - so return | |
74 | // } | |
75 | // } | |
76 | ||
1b446896 | 77 | return pair; |
78 | } | |
79 | ||
1b446896 | 80 | /******************************************************************/ |
fc13079c | 81 | /******************************************************************/ |
82 | /******************************************************************/ | |
83 | class AliHBTCorrelFunction | |
84 | { | |
85 | public: | |
86 | AliHBTCorrelFunction():fRatio(0x0){} | |
87 | AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){} | |
88 | virtual ~AliHBTCorrelFunction(){delete fRatio;} | |
89 | ||
90 | AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in); | |
91 | ||
92 | protected: | |
93 | TH1* fRatio;//!pointer to the ratio(result) | |
94 | ||
95 | ClassDef(AliHBTCorrelFunction,1) | |
96 | }; | |
97 | ||
98 | /******************************************************************/ | |
1b446896 | 99 | /******************************************************************/ |
100 | /******************************************************************/ | |
26f1270c | 101 | |
102 | //____________________ | |
103 | /////////////////////////////////////////////////////// | |
104 | // // | |
105 | // AliHBTOnePairFctn // | |
106 | // // | |
107 | // Abstract Base Calss for Functions that need // | |
108 | // one pair to fill function // | |
109 | // // | |
110 | // Piotr.Skowronski@cern.ch // | |
111 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
112 | // // | |
113 | /////////////////////////////////////////////////////// | |
114 | ||
115 | class AliHBTOnePairFctn | |
1b446896 | 116 | { |
117 | public: | |
27b3fe5d | 118 | AliHBTOnePairFctn(){} |
119 | virtual ~AliHBTOnePairFctn(){} | |
1b446896 | 120 | |
121 | virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0; | |
122 | virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0; | |
976183fd | 123 | |
26f1270c | 124 | virtual void Init() = 0; |
125 | virtual void Write() = 0; | |
8f0a515e | 126 | virtual const char* Name() = 0; |
1b446896 | 127 | |
26f1270c | 128 | ClassDef(AliHBTOnePairFctn,2) |
1b446896 | 129 | }; |
130 | /******************************************************************/ | |
131 | /******************************************************************/ | |
132 | /******************************************************************/ | |
26f1270c | 133 | |
134 | //____________________ | |
135 | /////////////////////////////////////////////////////// | |
136 | // // | |
137 | // AliHBTTwoPairFctn // | |
138 | // // | |
139 | // Abstract Base Calss for Functions that need // | |
140 | // two pairs to fill function, // | |
141 | // one reconstructed track and corresponding // | |
142 | // simulated pair // | |
143 | // Basically resolution functions // | |
144 | // Lednicky's algorithm uses that as well // | |
145 | // // | |
146 | // Piotr.Skowronski@cern.ch // | |
147 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
148 | // // | |
149 | /////////////////////////////////////////////////////// | |
150 | ||
151 | class AliHBTTwoPairFctn | |
1b446896 | 152 | { |
153 | public: | |
27b3fe5d | 154 | AliHBTTwoPairFctn(){}; |
155 | virtual ~AliHBTTwoPairFctn(){}; | |
1b446896 | 156 | |
157 | virtual void | |
158 | ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0; | |
159 | virtual void | |
160 | ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0; | |
26f1270c | 161 | |
162 | virtual void Init() = 0; | |
163 | virtual void Write() = 0; | |
8f0a515e | 164 | virtual const char* Name() = 0; |
1b446896 | 165 | |
26f1270c | 166 | ClassDef(AliHBTTwoPairFctn,2) |
1b446896 | 167 | |
168 | }; | |
169 | /******************************************************************/ | |
170 | /******************************************************************/ | |
171 | /******************************************************************/ | |
172 | ||
26f1270c | 173 | //____________________ |
174 | /////////////////////////////////////////////////////// | |
175 | // // | |
176 | // AliHBTFunction1D // | |
177 | // // | |
178 | // Base Calss for 1-dimensinal Functions // | |
179 | // // | |
180 | // Piotr.Skowronski@cern.ch // | |
181 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
182 | // // | |
183 | /////////////////////////////////////////////////////// | |
1b446896 | 184 | |
26f1270c | 185 | |
186 | class AliHBTFunction1D: public AliHBTFunction | |
1b446896 | 187 | { |
188 | public: | |
26f1270c | 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); | |
28cf76fa | 194 | |
195 | AliHBTFunction1D(const AliHBTFunction1D & source); | |
196 | AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/); | |
6e8d850a | 197 | |
26f1270c | 198 | virtual ~AliHBTFunction1D(); |
1b446896 | 199 | |
26f1270c | 200 | TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram |
201 | TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram | |
202 | ||
203 | Double_t Scale(); | |
204 | void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;} | |
1b446896 | 205 | |
1b446896 | 206 | protected: |
6e8d850a | 207 | //returns value to be histogrammed |
26f1270c | 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); | |
211 | ||
6e8d850a | 212 | TH1D* fNumerator; // Numerator histogram |
213 | TH1D* fDenominator; // Denumerator histogram | |
214 | UInt_t fNBinsToScale; // Number of bins to scale | |
215 | ||
216 | private: | |
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 | |
26f1270c | 222 | |
26f1270c | 223 | ClassDef(AliHBTFunction1D,2) |
1b446896 | 224 | }; |
225 | ||
1b446896 | 226 | /******************************************************************/ |
227 | /******************************************************************/ | |
228 | /******************************************************************/ | |
26f1270c | 229 | |
230 | //____________________ | |
231 | /////////////////////////////////////////////////////// | |
232 | // // | |
233 | // AliHBTFunction2D // | |
234 | // // | |
235 | // Base Calss for 2-dimensinal Functions // | |
236 | // // | |
237 | // Piotr.Skowronski@cern.ch // | |
238 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
239 | // // | |
240 | /////////////////////////////////////////////////////// | |
ba95ae3f | 241 | |
26f1270c | 242 | class AliHBTFunction2D: public AliHBTFunction |
1b446896 | 243 | { |
244 | public: | |
26f1270c | 245 | AliHBTFunction2D(); |
246 | ||
247 | AliHBTFunction2D(const Char_t *name, const Char_t *title); | |
248 | ||
249 | AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval, | |
250 | Int_t nYbins, Double_t maxYval, Double_t minYval); | |
251 | ||
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); | |
255 | ||
28cf76fa | 256 | AliHBTFunction2D(const AliHBTFunction2D & source); |
257 | ||
258 | AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/); | |
6e8d850a | 259 | |
26f1270c | 260 | virtual ~AliHBTFunction2D(); |
1b446896 | 261 | |
26f1270c | 262 | TH1* GetNumerator() const {return fNumerator;} |
263 | TH1* GetDenominator() const {return fDenominator;} | |
1b446896 | 264 | |
26f1270c | 265 | void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, |
266 | UInt_t yn = fgkDefaultNBinsToScaleY); | |
267 | ||
268 | Double_t Scale(); | |
1b446896 | 269 | protected: |
26f1270c | 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(); | |
273 | ||
6e8d850a | 274 | TH2D* fNumerator; // Numerator histogram |
275 | TH2D* fDenominator; // Denominator histogram | |
1b446896 | 276 | |
26f1270c | 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 | |
281 | ||
6e8d850a | 282 | private: |
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 | |
290 | ||
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 | |
293 | ||
26f1270c | 294 | ClassDef(AliHBTFunction2D,2) |
1b446896 | 295 | }; |
296 | /******************************************************************/ | |
297 | /******************************************************************/ | |
298 | /******************************************************************/ | |
299 | ||
26f1270c | 300 | //____________________ |
301 | /////////////////////////////////////////////////////// | |
302 | // // | |
303 | // AliHBTFunction3D // | |
304 | // // | |
305 | // Base Calss for 3-dimensinal Functions that need // | |
306 | // one pair to fill function // | |
307 | // // | |
308 | // Piotr.Skowronski@cern.ch // | |
309 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
310 | // // | |
311 | /////////////////////////////////////////////////////// | |
312 | ||
313 | class AliHBTFunction3D: public AliHBTFunction | |
1b446896 | 314 | { |
315 | public: | |
26f1270c | 316 | AliHBTFunction3D(); |
317 | ||
318 | AliHBTFunction3D(const Char_t *name, const Char_t *title); | |
319 | ||
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); | |
323 | ||
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); | |
6e8d850a | 328 | |
28cf76fa | 329 | AliHBTFunction3D(const AliHBTFunction3D & source); |
330 | AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/); | |
6e8d850a | 331 | |
26f1270c | 332 | virtual ~AliHBTFunction3D();//destructor |
333 | ||
334 | TH1* GetNumerator() const {return fNumerator;} | |
335 | TH1* GetDenominator() const {return fDenominator;} | |
1b446896 | 336 | |
26f1270c | 337 | |
338 | void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, | |
339 | UInt_t yn = fgkDefaultNBinsToScaleY, | |
340 | UInt_t zn = fgkDefaultNBinsToScaleZ); | |
341 | ||
342 | Double_t Scale(); | |
1b446896 | 343 | |
344 | protected: | |
26f1270c | 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(); | |
349 | ||
dd82cadc | 350 | TH3F* fNumerator; // Numerator histogram |
351 | TH3F* fDenominator; // Denominator histogram | |
26f1270c | 352 | |
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 | |
358 | ||
6e8d850a | 359 | private: |
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 | |
370 | ||
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 | |
374 | ||
26f1270c | 375 | ClassDef(AliHBTFunction3D,2) |
1b446896 | 376 | }; |
377 | /******************************************************************/ | |
378 | /******************************************************************/ | |
379 | /******************************************************************/ | |
380 | ||
26f1270c | 381 | //____________________ |
382 | /////////////////////////////////////////////////////// | |
383 | // // | |
384 | // AliHBTOnePairFctn1D // | |
385 | // // | |
386 | // Base Calss for 1-dimensinal Functions that need // | |
387 | // one pair to fill function // | |
388 | // // | |
389 | // Piotr.Skowronski@cern.ch // | |
390 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
391 | // // | |
392 | /////////////////////////////////////////////////////// | |
393 | ||
394 | class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D | |
ba95ae3f | 395 | { |
396 | public: | |
26f1270c | 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(){} | |
403 | ||
404 | void ProcessSameEventParticles(AliHBTPair* pair); | |
405 | void ProcessDiffEventParticles(AliHBTPair* pair); | |
c41732dc | 406 | void Write(){WriteFunction();} |
407 | void Init(){InitFunction();} | |
8f0a515e | 408 | const char* Name(){return GetName();} |
409 | ||
ba95ae3f | 410 | protected: |
26f1270c | 411 | //retruns velue to be histogrammed |
a22a56ec | 412 | virtual Double_t GetValue(AliHBTPair* pair) const = 0; |
26f1270c | 413 | ClassDef(AliHBTOnePairFctn1D,2) |
414 | }; | |
415 | /******************************************************************/ | |
416 | /******************************************************************/ | |
417 | /******************************************************************/ | |
ba95ae3f | 418 | |
26f1270c | 419 | //____________________ |
420 | /////////////////////////////////////////////////////// | |
421 | // // | |
422 | // AliHBTOnePairFctn2D // | |
423 | // // | |
424 | // Base Calss for 2-dimensinal Functions that need // | |
425 | // one pair to fill function // | |
426 | // // | |
427 | // Piotr.Skowronski@cern.ch // | |
428 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
429 | // // | |
430 | /////////////////////////////////////////////////////// | |
431 | ||
432 | class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D | |
433 | { | |
434 | public: | |
435 | AliHBTOnePairFctn2D(){} | |
4e871a8a | 436 | |
26f1270c | 437 | AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title); |
4e871a8a | 438 | |
26f1270c | 439 | AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, |
440 | Int_t nYbins, Double_t maxYval, Double_t minYval); | |
441 | ||
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); | |
445 | ||
446 | virtual ~AliHBTOnePairFctn2D(){} | |
447 | ||
448 | void ProcessSameEventParticles(AliHBTPair* pair); | |
449 | void ProcessDiffEventParticles(AliHBTPair* pair); | |
c41732dc | 450 | void Write(){WriteFunction();} |
451 | void Init(){InitFunction();} | |
8f0a515e | 452 | const char* Name(){return GetName();} |
26f1270c | 453 | protected: |
a22a56ec | 454 | virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0; |
26f1270c | 455 | ClassDef(AliHBTOnePairFctn2D,2) |
ba95ae3f | 456 | }; |
26f1270c | 457 | /******************************************************************/ |
458 | /******************************************************************/ | |
459 | /******************************************************************/ | |
1b446896 | 460 | |
26f1270c | 461 | //____________________ |
462 | /////////////////////////////////////////////////////// | |
463 | // // | |
464 | // AliHBTOnePairFctn3D // | |
465 | // // | |
466 | // Base Calss for 3-dimensinal Functions that need // | |
467 | // one pair to fill function // | |
468 | // // | |
469 | // Piotr.Skowronski@cern.ch // | |
470 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
471 | // // | |
472 | /////////////////////////////////////////////////////// | |
473 | ||
474 | class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D | |
475 | { | |
476 | public: | |
477 | AliHBTOnePairFctn3D(){} | |
1b446896 | 478 | |
26f1270c | 479 | AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title); |
480 | ||
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); | |
484 | ||
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); | |
489 | ||
490 | virtual ~AliHBTOnePairFctn3D(){}//destructor | |
491 | ||
492 | void ProcessSameEventParticles(AliHBTPair* pair); | |
493 | void ProcessDiffEventParticles(AliHBTPair* pair); | |
c41732dc | 494 | void Write(){WriteFunction();} |
495 | void Init(){InitFunction();} | |
8f0a515e | 496 | const char* Name(){return GetName();} |
26f1270c | 497 | protected: |
a22a56ec | 498 | virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0; |
26f1270c | 499 | ClassDef(AliHBTOnePairFctn3D,2) |
500 | }; | |
1b446896 | 501 | /******************************************************************/ |
502 | /******************************************************************/ | |
503 | /******************************************************************/ | |
26f1270c | 504 | |
505 | //____________________ | |
506 | /////////////////////////////////////////////////////// | |
507 | // // | |
508 | // AliHBTTwoPairFctn1D // | |
509 | // // | |
510 | // Base Calss for 1-dimensinal Functions that need // | |
511 | // two pair (simulated and reconstructed) // | |
512 | // to fill function // | |
513 | // // | |
514 | // Piotr.Skowronski@cern.ch // | |
515 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
516 | // // | |
517 | /////////////////////////////////////////////////////// | |
518 | ||
519 | class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D | |
1b446896 | 520 | { |
521 | public: | |
26f1270c | 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(){} | |
528 | ||
1b446896 | 529 | void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); |
530 | void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); | |
c41732dc | 531 | void Write(){WriteFunction();} |
532 | void Init(){InitFunction();} | |
8f0a515e | 533 | const char* Name(){return GetName();} |
c41732dc | 534 | |
1b446896 | 535 | protected: |
a22a56ec | 536 | virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0; |
6e8d850a | 537 | |
26f1270c | 538 | ClassDef(AliHBTTwoPairFctn1D,2) |
1b446896 | 539 | }; |
1b446896 | 540 | /******************************************************************/ |
541 | /******************************************************************/ | |
542 | /******************************************************************/ | |
26f1270c | 543 | |
544 | //____________________ | |
545 | /////////////////////////////////////////////////////// | |
546 | // // | |
547 | // AliHBTTwoPairFctn2D // | |
548 | // // | |
549 | // Base Calss for 2-dimensinal Functions that need // | |
550 | // two pair (simulated and reconstructed) // | |
551 | // to fill function // | |
552 | // // | |
553 | // Piotr.Skowronski@cern.ch // | |
554 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
555 | // // | |
556 | /////////////////////////////////////////////////////// | |
557 | ||
558 | class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D | |
ba95ae3f | 559 | { |
560 | public: | |
26f1270c | 561 | AliHBTTwoPairFctn2D(){} |
562 | ||
563 | AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title); | |
564 | ||
565 | AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, | |
566 | Int_t nYbins, Double_t maxYval, Double_t minYval); | |
567 | ||
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); | |
571 | ||
572 | virtual ~AliHBTTwoPairFctn2D(){} | |
ba95ae3f | 573 | |
574 | void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); | |
575 | void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); | |
c41732dc | 576 | void Write(){WriteFunction();} |
577 | void Init(){InitFunction();} | |
8f0a515e | 578 | const char* Name(){return GetName();} |
26f1270c | 579 | |
ba95ae3f | 580 | protected: |
a22a56ec | 581 | virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0; |
ba95ae3f | 582 | |
26f1270c | 583 | ClassDef(AliHBTTwoPairFctn2D,2) |
ba95ae3f | 584 | }; |
1b446896 | 585 | /******************************************************************/ |
586 | /******************************************************************/ | |
587 | /******************************************************************/ | |
588 | ||
26f1270c | 589 | //____________________ |
590 | /////////////////////////////////////////////////////// | |
591 | // // | |
592 | // AliHBTTwoPairFctn3D // | |
593 | // // | |
594 | // Base Calss for 3-dimensinal Functions that need // | |
595 | // two pair (simulated and reconstructed) // | |
596 | // to fill function // | |
597 | // // | |
598 | // Piotr.Skowronski@cern.ch // | |
599 | // http://alisoft.cern.ch/people/skowron/analyzer // | |
600 | // // | |
601 | /////////////////////////////////////////////////////// | |
602 | ||
603 | class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D | |
604 | { | |
605 | public: | |
606 | AliHBTTwoPairFctn3D(){} | |
607 | ||
608 | AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title); | |
609 | ||
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); | |
613 | ||
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); | |
618 | ||
619 | virtual ~AliHBTTwoPairFctn3D(){}//destructor | |
1b446896 | 620 | |
26f1270c | 621 | void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); |
622 | void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair); | |
c41732dc | 623 | void Write(){WriteFunction();} |
624 | void Init(){InitFunction();} | |
8f0a515e | 625 | const char* Name(){return GetName();} |
26f1270c | 626 | |
627 | protected: | |
a22a56ec | 628 | virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0; |
26f1270c | 629 | |
26f1270c | 630 | ClassDef(AliHBTTwoPairFctn3D,2) |
631 | }; | |
1b446896 | 632 | |
633 | #endif |