HBTAN/AliHBTFunction.cxx

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