e2738003f35974b21251a306aad2aa92f2e9ec22
[u/mrichter/AliRoot.git] / HBTAN / AliHBTFunction.cxx
1 #include "AliHBTFunction.h"
2 //____________________
3 //////////////////////////////////////////////////////////////////////
4 //
5 //AliHBTFunction
6 //Author: Piotr Krzysztof Skowronski
7 //Piotr.Skowronski@cern.ch
8 /*Base classes for HBT functions
9
10  OnePairFctn       unction                  TwoPairFctn
11    | \    \        /  |   \                      /|\   
12    |  \    \      /   |    \                    / | \    
13    |   \    \   1D   2D    3D                  /  |  \    
14    |    \    \  / \   |\   | \________________/__ |   \             
15    |     \    \/   \  | \__|_____________    /   \|    \             
16    |      \    \    \_|____|__           \  /     |     \            
17    |       \ /  \___  |    |  \           \/      |\     \              
18    |        /       \ |    |   \          /\      | \     \             
19    |       / \       \|    |    \        /  \     |  \     \              
20    |      /   \      /\    |     \      /    \    |   \     |              
21    |     /     \    /  \   |      \    /      \   |    \    |               
22    |    /       \  /    \  |       \  /        \  |     \   |                 
23    |   /         \/      \ |        \/          \ |      \  |               
24  OnePair1D   OnePair2D  OnePair3D  TwoPair1D  TwoPair2D TwoPair3D
25
26
27
28  four particle functions are intendent to be resolution functions:
29  it is mecessary to have simulated particle pair corresponding to given
30  recontructed track pair in order to calculate function simualted value 
31  and recontructed value to be further histogrammed
32  
33 */
34 /////////////////////////////////////////////////////////////////////// 
35
36 /******************************************************************/
37 /******************************************************************/
38
39 ClassImp( AliHBTFunction )
40
41 AliHBTFunction::AliHBTFunction()
42 {
43   fPairCut = new AliHBTEmptyPairCut(); //dummy cut
44 }
45 /******************************************************************/
46 AliHBTFunction::AliHBTFunction(const char* name,const char* title):TNamed(name,title)
47 {
48   fPairCut = new AliHBTEmptyPairCut(); //dummy cut
49 }
50 /******************************************************************/
51
52 AliHBTFunction::~AliHBTFunction()
53  {
54   delete fPairCut;
55  }
56 /******************************************************************/
57
58 void AliHBTFunction::Write()
59  {
60    if (GetNumerator()) GetNumerator()->Write();
61    if (GetDenominator()) GetDenominator()->Write();
62    TH1* res = GetResult();
63    if (res) res->Write();
64  }
65 /******************************************************************/
66
67 TH1* AliHBTFunction::GetRatio(Double_t normfactor)
68  {
69    if (gDebug>0) Info("GetRatio","Norm. Factor is %f for %s",normfactor,GetName());
70    
71    if (normfactor == 0.0)
72     {
73       Error("GetRatio","Scaling Factor is 0. Null poiner returned");
74       return 0x0;
75     }
76    TString str = fName + " ratio";
77    TH1 *result = (TH1*)GetNumerator()->Clone(str.Data());
78    
79    result->SetTitle(str.Data());
80    
81    result->Divide(GetNumerator(),GetDenominator(),normfactor);
82    
83    return result;
84    
85  }
86 /******************************************************************/
87 void AliHBTFunction::SetPairCut(AliHBTPairCut* cut)
88 {
89 //Sets new Pair Cut. Old one is deleted
90 //Note that it is created new object instead of simple pointer set
91 //I do not want to have pointer 
92 //to object created somewhere else
93 //because in that case I could not believe that 
94 //it would always exist (sb could delete it)
95 //so we have always own copy
96
97  if(!cut) 
98    {
99      Error("AliHBTFunction::SetPairCut","argument is NULL");
100      return;
101    }
102  delete fPairCut;
103  fPairCut = (AliHBTPairCut*)cut->Clone();
104  
105 }
106
107 /******************************************************************/
108
109 void AliHBTFunction::Rename(const Char_t * name)
110  {
111  //renames the function and histograms
112   SetName(name);
113   SetTitle(name);
114   
115   TString numstr = fName + " Numerator";  //title and name of the 
116                                            //numerator histogram
117   TString denstr = fName + " Denominator";//title and name of the 
118                                            //denominator histogram
119  
120   GetNumerator()->SetName(numstr.Data());
121   GetNumerator()->SetTitle(numstr.Data());
122   
123   GetDenominator()->SetName(denstr.Data());
124   GetDenominator()->SetTitle(denstr.Data());
125   
126  }
127
128 void AliHBTFunction::Rename(const Char_t * name, const Char_t * title)
129  {
130  //renames and retitle the function and histograms
131  
132   SetName(name);
133   SetTitle(title);
134   
135   TString numstrn = fName + " Numerator";  //name of the 
136                                            //numerator histogram
137
138   TString numstrt = fTitle + " Numerator";  //title of the 
139                                            //numerator histogram
140                    
141   TString denstrn = fName + " Denominator";//name of the 
142                                            //denominator histogram
143
144   TString denstrt = fTitle + " Denominator";//title of the 
145                                            //denominator histogram
146                    
147  
148   GetNumerator()->SetName(numstrn.Data());
149   GetNumerator()->SetTitle(numstrt.Data());
150   
151   GetDenominator()->SetName(denstrn.Data());
152   GetDenominator()->SetTitle(denstrt.Data());
153
154
155  }
156 /******************************************************************/
157
158 void AliHBTFunction::Init()
159 {
160 //Iniotializes fctn.: Resets histograms
161 //In case histograms are not created in ctor, builds with default parameters
162   if ( !(GetNumerator()&&GetDenominator()) ) BuildHistos();
163   GetNumerator()->Reset();
164   GetDenominator()->Reset();
165 }
166
167 /******************************************************************/
168 /******************************************************************/
169 /******************************************************************/
170
171 ClassImp( AliHBTOnePairFctn )
172
173 /******************************************************************/
174 /******************************************************************/
175 /******************************************************************/
176
177 ClassImp( AliHBTTwoPairFctn)
178
179 /******************************************************************/
180 /******************************************************************/
181 /******************************************************************/
182
183 ClassImp( AliHBTFunction1D )
184
185 const Int_t AliHBTFunction1D::fgkDefaultNBins = 100;
186 const Float_t AliHBTFunction1D::fgkDefaultMin = 0.0;
187 const Float_t AliHBTFunction1D::fgkDefaultMax = 0.15;
188 const UInt_t AliHBTFunction1D::fgkDefaultNBinsToScale = 30;
189
190
191 AliHBTFunction1D::AliHBTFunction1D():
192  fNumerator(0x0),
193  fDenominator(0x0),
194  fNBinsToScale(fgkDefaultNBinsToScale)
195 {
196 }
197 /******************************************************************/
198
199 AliHBTFunction1D::AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval):
200  fNumerator(0x0),
201  fDenominator(0x0),
202  fNBinsToScale(fgkDefaultNBinsToScale)
203 {
204  //Constructor of Two Part One Dimentional Function 
205  // nbins: number of bins in histograms - default 100
206  // maxXval and minXval: range of histgram(s) default 0 - 0.15 (GeV)
207  BuildHistos(nbins,maxXval,minXval);
208 }
209 /******************************************************************/
210 AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title):
211  AliHBTFunction(name,title),
212  fNumerator(0x0),
213  fDenominator(0x0),
214  fNBinsToScale(fgkDefaultNBinsToScale)
215 {
216 }
217 /******************************************************************/
218 AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title,
219                                    Int_t nbins, Float_t maxXval, Float_t minXval):
220  AliHBTFunction(name,title),
221  fNumerator(0x0),
222  fDenominator(0x0),
223  fNBinsToScale(fgkDefaultNBinsToScale)
224 {
225    BuildHistos(nbins,maxXval,minXval);
226 }
227 /******************************************************************/
228
229 AliHBTFunction1D::~AliHBTFunction1D()
230 {
231   delete fNumerator;
232   delete fDenominator;
233 }
234 /******************************************************************/
235 void AliHBTFunction1D::BuildHistos()
236 {
237  BuildHistos(fgkDefaultNBins,fgkDefaultMax,fgkDefaultMin);
238 }
239
240 /******************************************************************/
241
242 void AliHBTFunction1D::BuildHistos(Int_t nbins, Float_t max, Float_t min)
243 {
244   TString numstr = fName + " Numerator";  //title and name of the 
245                                           //numerator histogram
246   TString denstr = fName + " Denominator";//title and name of the 
247                                           //denominator histogram
248   fNumerator   = new TH1D(numstr.Data(),numstr.Data(),nbins,min,max);
249   fDenominator = new TH1D(denstr.Data(),denstr.Data(),nbins,min,max);
250    
251   fNumerator->Sumw2();
252   fDenominator->Sumw2();
253 }
254 /******************************************************************/
255
256 Double_t AliHBTFunction1D::Scale()
257 {
258  //Calculates the factor that should be used to scale 
259  //quatience of fNumerator and fDenominator to 1 at tail
260  return Scale(fNumerator,fDenominator);
261 }
262 /******************************************************************/
263
264 Double_t AliHBTFunction1D::Scale(TH1D* num,TH1D* den)
265 {
266  //Calculates the factor that should be used to scale 
267  //quatience of num and den to 1 at tail
268  
269   if (gDebug>0) Info("Scale","Enetered Scale()");
270   if(!num) 
271    {
272      Error("Scale","No numerator");
273      return 0.0;
274    }
275   if(!den) 
276    {
277      Error("Scale","No denominator");
278      return 0.0;
279    }
280   
281   if(fNBinsToScale < 1) 
282    {
283     return 0.0;
284     Error("Scale","Number of bins for scaling is smaller thnan 1");
285    }
286   UInt_t nbins = num->GetNbinsX();
287   if (fNBinsToScale > nbins) 
288    {
289     Error("Scale","Number of bins for scaling is bigger thnan number of bins in histograms");
290     return 0.0;
291    }
292   if (gDebug>0) Info("Scale","No errors detected");
293
294   Double_t ratio;
295   Double_t sum = 0;
296   Int_t N = 0;
297   
298   Int_t offset = nbins - fNBinsToScale - 1; 
299   UInt_t i;
300   for ( i = offset; i< nbins; i++)
301    {
302     if ( num->GetBinContent(i) > 0.0 )
303      {
304        ratio = den->GetBinContent(i)/num->GetBinContent(i);
305        sum += ratio;
306        N++;
307      }
308    }
309   
310   if(gDebug > 0) Info("Scale","sum=%f fNBinsToScale=%d N=%d",sum,fNBinsToScale,N);
311   
312   if (N == 0) return 0.0;
313   Double_t ret = sum/((Double_t)N);
314
315   if(gDebug > 0) Info("Scale","returning %f",ret);
316   return ret;
317
318
319 /******************************************************************/
320 /******************************************************************/
321 /******************************************************************/
322
323 //____________________
324 ///////////////////////////////////////////////////////
325 //                                                   //
326 // AliHBTFunction2D                                  //
327 //                                                   //
328 // Base Calss for 2-dimensinal Functions             //
329 //                                                   //
330 // Piotr.Skowronski@cern.ch                          //
331 // http://alisoft.cern.ch/people/skowron/analyzer    //
332 //                                                   //
333 ///////////////////////////////////////////////////////
334
335 ClassImp( AliHBTFunction1D )
336
337 const Int_t AliHBTFunction2D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
338 const Float_t AliHBTFunction2D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
339 const Float_t AliHBTFunction2D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
340
341 const Int_t AliHBTFunction2D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
342 const Float_t AliHBTFunction2D::fgkDefaultMinY = -0.15;//Default min value of histograms
343 const Float_t AliHBTFunction2D::fgkDefaultMaxY =  0.15;//Default max value of histograms
344
345 const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
346 const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
347
348 /******************************************************************/
349 AliHBTFunction2D::AliHBTFunction2D():
350  fNumerator(0x0),
351  fDenominator(0x0),
352  fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
353  fNBinsToScaleY(fgkDefaultNBinsToScaleY)
354 {//default constructor
355 }
356 /******************************************************************/
357 AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title):
358  AliHBTFunction(name,title),
359  fNumerator(0x0),
360  fDenominator(0x0),
361  fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
362  fNBinsToScaleY(fgkDefaultNBinsToScaleY)
363 {//constructor
364 }
365 /******************************************************************/
366
367 AliHBTFunction2D::AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
368                                    Int_t nYbins, Double_t maxYval, Double_t minYval):
369  fNumerator(0x0),
370  fDenominator(0x0),
371  fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
372  fNBinsToScaleY(fgkDefaultNBinsToScaleY)
373 {
374   BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
375 }         
376 /******************************************************************/
377
378 AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title,
379                                    Int_t nXbins, Double_t maxXval, Double_t minXval,
380                                    Int_t nYbins, Double_t maxYval, Double_t minYval):
381  AliHBTFunction(name,title),
382  fNumerator(0x0),
383  fDenominator(0x0),
384  fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
385  fNBinsToScaleY(fgkDefaultNBinsToScaleY)
386 {
387   BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
388 }         
389 /******************************************************************/
390
391 AliHBTFunction2D::~AliHBTFunction2D()
392 {
393   delete fNumerator;
394   delete fDenominator;
395 }
396 /******************************************************************/
397
398 void AliHBTFunction2D::BuildHistos()
399 {
400 //Creates default histograms
401   BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
402               fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY);
403 }
404 /******************************************************************/
405
406 void AliHBTFunction2D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
407                                    Int_t nybins, Float_t ymax, Float_t ymin)
408 {
409  TString numstr = fName + " Numerator";  //title and name of the 
410                                            //numerator histogram
411  TString denstr = fName + " Denominator";//title and name of the 
412                                            //denominator histogram
413          
414  fNumerator   = new TH2D(numstr.Data(),numstr.Data(),
415                          nxbins,xmin,xmax,nybins,ymin,ymax);
416                
417  fDenominator = new TH2D(denstr.Data(),denstr.Data(),
418                          nxbins,xmin,xmax,nybins,ymin,ymax);
419  
420  fNumerator->Sumw2();
421  fDenominator->Sumw2();
422 }
423 /******************************************************************/
424
425 void AliHBTFunction2D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn)
426 {
427 //defines area used for scaling factor calculation
428   fNBinsToScaleX = xn;
429   fNBinsToScaleY = yn;
430 }
431 /******************************************************************/
432
433 Double_t AliHBTFunction2D::Scale()
434 {
435   if (gDebug>0) Info("Scale","Enetered Scale()");
436   if(!fNumerator) 
437    {
438      Error("Scale","No numerator");
439      return 0.0;
440    }
441   if(!fDenominator) 
442    {
443      Error("Scale","No denominator");
444      return 0.0;
445    }
446   
447   if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) ) 
448    {
449     return 0.0;
450     Error("Scale","Number of bins for scaling is smaller thnan 1");
451    }
452   UInt_t nbinsX = fNumerator->GetNbinsX();
453   if (fNBinsToScaleX > nbinsX) 
454    {
455     Error("Scale","Number of X bins for scaling is bigger thnan number of bins in histograms");
456     return 0.0;
457    }
458    
459   UInt_t nbinsY = fNumerator->GetNbinsX();
460   if (fNBinsToScaleY > nbinsY) 
461    {
462     Error("Scale","Number of Y bins for scaling is bigger thnan number of bins in histograms");
463     return 0.0;
464    }
465
466   if (gDebug>0) Info("Scale","No errors detected");
467
468   Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
469   Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis X
470
471   Double_t ratio;
472   Double_t sum = 0;
473   Int_t N = 0;
474   
475   UInt_t i,j;
476   for ( j = offsetY; j< nbinsY; j++)
477     for ( i = offsetX; i< nbinsX; i++)
478      {
479       if ( fNumerator->GetBinContent(i,j) > 0.0 )
480        {
481          ratio = fDenominator->GetBinContent(i,j)/fNumerator->GetBinContent(i,j);
482          sum += ratio;
483          N++;
484        }
485      }
486   
487   if(gDebug > 0) Info("Scale","sum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d N=%d",sum,fNBinsToScaleX,fNBinsToScaleY,N);
488   
489   if (N == 0) return 0.0;
490   Double_t ret = sum/((Double_t)N);
491
492   if(gDebug > 0) Info("Scale","returning %f",ret);
493   return ret;
494
495
496 /******************************************************************/
497 /******************************************************************/
498 /******************************************************************/
499
500 //____________________
501 ///////////////////////////////////////////////////////
502 //                                                   //
503 // AliHBTFunction3D                                  //
504 //                                                   //
505 // Base Calss for 3-dimensinal Functions             //
506 //                                                   //
507 // Piotr.Skowronski@cern.ch                          //
508 // http://alisoft.cern.ch/people/skowron/analyzer    //
509 //                                                   //
510 ///////////////////////////////////////////////////////
511
512 ClassImp( AliHBTFunction3D)
513
514 const Int_t AliHBTFunction3D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
515 const Float_t AliHBTFunction3D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
516 const Float_t AliHBTFunction3D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
517
518 const Int_t AliHBTFunction3D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
519 const Float_t AliHBTFunction3D::fgkDefaultMinY = -0.15;//Default min value of histograms
520 const Float_t AliHBTFunction3D::fgkDefaultMaxY =  0.15;//Default max value of histograms
521
522 const Int_t AliHBTFunction3D::fgkDefaultNBinsZ = 200;//default number of Bins in histograms
523 const Float_t AliHBTFunction3D::fgkDefaultMinZ = -0.15;//Default min value of histograms
524 const Float_t AliHBTFunction3D::fgkDefaultMaxZ =  0.15;//Default max value of histograms
525
526 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
527 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
528 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleZ = 30;//Default number of bins used for scaling to tale
529
530
531 AliHBTFunction3D::AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
532                   Int_t nYbins, Double_t maxYval, Double_t minYval, 
533                   Int_t nZbins, Double_t maxZval, Double_t minZval):
534  fNumerator(0x0),
535  fDenominator(0x0),
536  fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
537  fNBinsToScaleY(fgkDefaultNBinsToScaleY),
538  fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
539 {
540 }         
541 /******************************************************************/
542
543 AliHBTFunction3D::~AliHBTFunction3D()
544 {
545   delete fNumerator;
546   delete fDenominator;
547 }
548 /******************************************************************/
549
550 void AliHBTFunction3D::BuildHistos()
551 {
552 //Creates default histograms
553   BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
554               fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY,
555               fgkDefaultNBinsZ,fgkDefaultMaxZ,fgkDefaultMinZ);
556 }
557 /******************************************************************/
558
559 void AliHBTFunction3D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
560                                    Int_t nybins, Float_t ymax, Float_t ymin,
561                        Int_t nzbins, Float_t zmax, Float_t zmin)
562 {
563    TString numstr = fName + " Numerator";  //title and name of the 
564                                            //numerator histogram
565    TString denstr = fName + " Denominator";//title and name of the 
566                                            //denominator histogram
567          
568    fNumerator   = new TH3D(numstr.Data(),numstr.Data(),
569                            nxbins,xmin,xmin,nybins,ymin,ymin,nzbins,zmin,zmin);
570                
571    fDenominator = new TH3D(denstr.Data(),denstr.Data(),
572                            nxbins,xmin,xmin,nybins,ymin,ymin,nzbins,zmin,zmin);
573    
574    fNumerator->Sumw2();
575    fDenominator->Sumw2();
576 }
577
578 /******************************************************************/
579
580 Double_t AliHBTFunction3D::Scale()
581 {
582   if (gDebug>0) Info("Scale","Enetered Scale()");
583   if(!fNumerator) 
584    {
585      Error("Scale","No numerator");
586      return 0.0;
587    }
588   if(!fDenominator) 
589    {
590      Error("Scale","No denominator");
591      return 0.0;
592    }
593   
594   if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) || (fNBinsToScaleZ < 1)) 
595    {
596     return 0.0;
597     Error("Scale","Number of bins for scaling is smaller thnan 1");
598    }
599   UInt_t nbinsX = fNumerator->GetNbinsX();
600   if (fNBinsToScaleX > nbinsX) 
601    {
602     Error("Scale","Number of X bins for scaling is bigger thnan number of bins in histograms");
603     return 0.0;
604    }
605    
606   UInt_t nbinsY = fNumerator->GetNbinsX();
607   if (fNBinsToScaleY > nbinsY) 
608    {
609     Error("Scale","Number of Y bins for scaling is bigger thnan number of bins in histograms");
610     return 0.0;
611    }
612
613   UInt_t nbinsZ = fNumerator->GetNbinsZ();
614   if (fNBinsToScaleZ > nbinsZ) 
615    {
616     Error("Scale","Number of Z bins for scaling is bigger thnan number of bins in histograms");
617     return 0.0;
618    }
619
620   if (gDebug>0) Info("Scale","No errors detected");
621
622   Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
623   Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis Y
624   Int_t offsetZ = nbinsZ - fNBinsToScaleZ - 1; //bin that we start loop over bins in axis Z
625
626   Double_t ratio;
627   Double_t sum = 0;
628   Int_t N = 0;
629   
630   for (UInt_t k = offsetZ; k<nbinsZ; k++)
631     for (UInt_t j = offsetY; j<nbinsY; j++)
632       for (UInt_t i = offsetX; i<nbinsX; i++)
633        {
634         if ( fNumerator->GetBinContent(i,j,k) > 0.0 )
635          {
636            ratio = fDenominator->GetBinContent(i,j,k)/fNumerator->GetBinContent(i,j,k);
637            sum += ratio;
638            N++;
639          }
640        }
641   
642   if(gDebug > 0) 
643     Info("Scale","sum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d fNBinsToScaleZ=%d N=%d",
644           sum,fNBinsToScaleX,fNBinsToScaleY,fNBinsToScaleZ,N);
645   
646   if (N == 0) return 0.0;
647   Double_t ret = sum/((Double_t)N);
648
649   if(gDebug > 0) Info("Scale","returning %f",ret);
650   return ret;
651
652
653 /******************************************************************/
654 /******************************************************************/
655 /******************************************************************/
656 /******************************************************************/
657 /******************************************************************/
658 /******************************************************************/
659 /******************************************************************/
660 /******************************************************************/
661 /******************************************************************/
662
663 //____________________
664 ///////////////////////////////////////////////////////
665 //                                                   //
666 // AliHBTOnePairFctn1D                               //
667 //                                                   //
668 // Base Calss for 1-dimensinal Functions that need   //
669 // one pair to fill function                         //
670 //                                                   //
671 // Piotr.Skowronski@cern.ch                          //
672 // http://alisoft.cern.ch/people/skowron/analyzer    //
673 //                                                   //
674 ///////////////////////////////////////////////////////
675
676 ClassImp( AliHBTOnePairFctn1D )
677 /******************************************************************/
678
679 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
680  AliHBTFunction1D(nbins,maxXval,minXval)
681 {
682 }
683 /******************************************************************/
684
685 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title):
686  AliHBTFunction1D(name,title)
687 {
688 }
689 /******************************************************************/
690
691 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
692                                          Int_t nbins, Float_t maxXval, Float_t minXval):
693  AliHBTFunction1D(name,title,nbins,maxXval,minXval)
694 {
695 }
696 /******************************************************************/
697
698 void AliHBTOnePairFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
699 {
700  //Fills the numerator
701    pair = CheckPair(pair);
702    if(pair) fNumerator->Fill(GetValue(pair));
703 }
704 /******************************************************************/
705 void AliHBTOnePairFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
706  {
707   //fills denumerator
708    pair = CheckPair(pair);
709    if(pair) fDenominator->Fill(GetValue(pair));
710   }
711
712 /******************************************************************/
713 /******************************************************************/
714 /******************************************************************/
715
716 //____________________
717 ///////////////////////////////////////////////////////
718 //                                                   //
719 // AliHBTOnePairFctn2D                               //
720 //                                                   //
721 // Base Calss for 2-dimensinal Functions that need   //
722 // one pair to fill function                         //
723 //                                                   //
724 // Piotr.Skowronski@cern.ch                          //
725 // http://alisoft.cern.ch/people/skowron/analyzer    //
726 //                                                   //
727 ///////////////////////////////////////////////////////
728
729 ClassImp( AliHBTOnePairFctn2D )
730 /******************************************************************/
731
732 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title):
733  AliHBTFunction2D(name,title)
734 {
735 }
736 /******************************************************************/
737
738 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
739                       Int_t nYbins, Double_t maxYval, Double_t minYval):
740  AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
741 {
742 }
743 /******************************************************************/
744
745 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
746                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
747                       Int_t nYbins, Double_t maxYval, Double_t minYval):
748  AliHBTFunction2D(name,title, nXbins, maxXval, minXval, nYbins, maxYval, minYval)
749 {
750 }
751 /******************************************************************/
752
753 void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
754 {
755   pair = CheckPair(pair);
756   if(pair) 
757    { 
758      Double_t x,y;
759      GetValues(pair,x,y);
760      fNumerator->Fill(x,y);
761    }
762 }
763 /******************************************************************/
764
765 void AliHBTOnePairFctn2D::ProcessDiffEventParticles(AliHBTPair* pair)
766 {
767   pair = CheckPair(pair);
768   if(pair) 
769    { 
770      Double_t x,y;
771      GetValues(pair,x,y);
772      fDenominator->Fill(x,y);
773    }
774 }
775 /******************************************************************/
776 /******************************************************************/
777 /******************************************************************/
778 /******************************************************************/
779 //____________________
780 ///////////////////////////////////////////////////////
781 //                                                   //
782 // AliHBTOnePairFctn3D                               //
783 //                                                   //
784 // Base Calss for 3-dimensinal Functions that need   //
785 // one pair to fill function                         //
786 //                                                   //
787 // Piotr.Skowronski@cern.ch                          //
788 // http://alisoft.cern.ch/people/skowron/analyzer    //
789 //                                                   //
790 ///////////////////////////////////////////////////////
791 ClassImp( AliHBTOnePairFctn3D)
792
793 /******************************************************************/
794
795 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title):
796  AliHBTFunction3D(name,title)
797 {
798 }
799 /******************************************************************/
800
801 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
802                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
803                       Int_t nZbins, Double_t maxZval, Double_t minZval):
804  AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
805 {
806 }
807 /******************************************************************/
808
809 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
810                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
811                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
812                       Int_t nZbins, Double_t maxZval, Double_t minZval):
813  AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
814 {
815 }
816 /******************************************************************/
817
818 void AliHBTOnePairFctn3D::ProcessSameEventParticles(AliHBTPair* pair)
819 {
820 //Reacts on pair coming from same event (real pairs)
821 //and fills numerator histogram
822   pair  = CheckPair(pair);
823   if( pair ) 
824    { 
825      Double_t x,y,z;
826      GetValues(pair,x,y,z);
827      fNumerator->Fill(x,y,z);
828    }
829 }
830 /******************************************************************/
831
832 void AliHBTOnePairFctn3D::ProcessDiffEventParticles(AliHBTPair* pair)
833 {
834 //Reacts on pair coming from different events (mixed pairs)
835 //and fills denominator histogram
836   pair  = CheckPair(pair);
837   if( pair ) 
838    { 
839      Double_t x,y,z;
840      GetValues(pair,x,y,z);
841      fDenominator->Fill(x,y,z);
842    }
843 }
844
845 /******************************************************************/
846 /******************************************************************/
847 /******************************************************************/
848
849 //____________________
850 ///////////////////////////////////////////////////////
851 //                                                   //
852 // AliHBTTwoPairFctn1D                               //
853 //                                                   //
854 // Base Calss for 1-dimensinal Functions that need   //
855 // two pair (simulated and reconstructed)            //
856 // to fill function                                  //
857 //                                                   //
858 // Piotr.Skowronski@cern.ch                          //
859 // http://alisoft.cern.ch/people/skowron/analyzer    //
860 //                                                   //
861 ///////////////////////////////////////////////////////
862 ClassImp(AliHBTTwoPairFctn1D)
863 /******************************************************************/
864
865 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
866  AliHBTFunction1D(nbins,maxXval,minXval)
867 {
868 }
869 /******************************************************************/
870
871 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title):
872  AliHBTFunction1D(name,title)
873 {
874 }
875 /******************************************************************/
876
877 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
878                                          Int_t nbins, Float_t maxXval, Float_t minXval):
879  AliHBTFunction1D(name,title,nbins,maxXval,minXval)
880 {
881 }
882 /******************************************************************/
883
884 void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
885 {
886   partpair  = CheckPair(partpair);
887   if( partpair ) 
888    { 
889      Double_t x = GetValue(trackpair,partpair);
890      fNumerator->Fill(x);
891    }
892 }
893 /******************************************************************/
894
895 void AliHBTTwoPairFctn1D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
896 {
897   partpair  = CheckPair(partpair);
898   if( partpair )
899    { 
900      Double_t x = GetValue(trackpair,partpair);
901      fDenominator->Fill(x);
902    }
903 }
904 /******************************************************************/
905 /******************************************************************/
906 /******************************************************************/
907
908 //____________________
909 ///////////////////////////////////////////////////////
910 //                                                   //
911 // AliHBTTwoPairFctn2D                               //
912 //                                                   //
913 // Base Calss for 2-dimensinal Functions that need   //
914 // two pair (simulated and reconstructed)            //
915 // to fill function                                  //
916 //                                                   //
917 // Piotr.Skowronski@cern.ch                          //
918 // http://alisoft.cern.ch/people/skowron/analyzer    //
919 //                                                   //
920 ///////////////////////////////////////////////////////
921
922 ClassImp(AliHBTTwoPairFctn2D)
923
924 /******************************************************************/
925
926 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title):
927  AliHBTFunction2D(name,title)
928 {
929 }
930 /******************************************************************/
931
932 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
933                       Int_t nYbins, Double_t maxYval, Double_t minYval):
934  AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
935 {
936 }
937 /******************************************************************/
938
939 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
940                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
941                       Int_t nYbins, Double_t maxYval, Double_t minYval):
942  AliHBTFunction2D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval)
943 {
944 }
945 /******************************************************************/
946
947 void AliHBTTwoPairFctn2D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
948 {
949   partpair  = CheckPair(partpair);
950   if( partpair ) 
951    { 
952      Double_t x,y;
953      GetValues(trackpair,partpair,x,y);
954      fNumerator->Fill(x,y);
955    }
956 }
957 /******************************************************************/
958
959 void AliHBTTwoPairFctn2D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
960 {
961   partpair  = CheckPair(partpair);
962   if( partpair ) 
963    { 
964      Double_t x,y;
965      GetValues(trackpair,partpair,x,y);
966      fDenominator->Fill(x,y);
967    }
968
969 }
970
971 /******************************************************************/
972 /******************************************************************/
973 /******************************************************************/
974
975 //____________________
976 ///////////////////////////////////////////////////////
977 //                                                   //
978 // AliHBTTwoPairFctn3D                               //
979 //                                                   //
980 // Base Calss for 3-dimensinal Functions that need   //
981 // two pair (simulated and reconstructed)            //
982 // to fill function                                  //
983 //                                                   //
984 // Piotr.Skowronski@cern.ch                          //
985 // http://alisoft.cern.ch/people/skowron/analyzer    //
986 //                                                   //
987 ///////////////////////////////////////////////////////
988
989 ClassImp(AliHBTTwoPairFctn3D)
990
991 /******************************************************************/
992
993 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title):
994  AliHBTFunction3D(name,title)
995 {
996 }
997 /******************************************************************/
998
999 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
1000                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
1001                       Int_t nZbins, Double_t maxZval, Double_t minZval):
1002  AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1003 {
1004 }
1005 /******************************************************************/
1006
1007 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
1008                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
1009                       Int_t nYbins, Double_t maxYval, Double_t minYval, 
1010                       Int_t nZbins, Double_t maxZval, Double_t minZval):
1011  AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1012 {
1013 }
1014 /******************************************************************/
1015
1016 void AliHBTTwoPairFctn3D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1017 {
1018   partpair  = CheckPair(partpair);
1019   if( partpair ) 
1020    { 
1021      Double_t x,y,z;
1022      GetValues(trackpair,partpair,x,y,z);
1023      fNumerator->Fill(x,y,z);
1024    }
1025 }
1026 /******************************************************************/
1027
1028 void AliHBTTwoPairFctn3D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1029 {
1030   partpair  = CheckPair(partpair);
1031   if( partpair ) 
1032    { 
1033      Double_t x,y,z;
1034      GetValues(trackpair,partpair,x,y,z);
1035      fDenominator->Fill(x,y,z);
1036    }
1037
1038 }
1039
1040
1041 /******************************************************************/
1042 /******************************************************************/
1043 /******************************************************************/
1044