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