Function base classes redesign
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 11 Nov 2002 10:22:54 +0000 (10:22 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 11 Nov 2002 10:22:54 +0000 (10:22 +0000)
HBTAN/AliHBTFunction.cxx
HBTAN/AliHBTFunction.h
HBTAN/HBTAnalysisLinkDef.h

index 3a4228f3dd3a08260f9e3c5d132b307dc99c9b43..534f9685b90d566c643014dec9a5eaf0b3845261 100644 (file)
@@ -1,22 +1,29 @@
 #include "AliHBTFunction.h"
-/******************************************************************/
-/*
-Piotr Krzysztof Skowronski
-Piotr.Skowronski@cern.ch
-Base classes for HBT functions
-
-             function
-              /    \
-             /      \
-            /        \
-           /          \
-          /            \
-         /              \
-        /                \
-    one pair          two pair 
-    /   |   \         /   |   \
-   /    |    \       /    |    \
-  1D   2D    3D     1D   2D    3D
+//____________________
+//////////////////////////////////////////////////////////////////////
+//
+//AliHBTFunction
+//Author: Piotr Krzysztof Skowronski
+//Piotr.Skowronski@cern.ch
+/*Base classes for HBT functions
+
+ OnePairFctn       unction                  TwoPairFctn
+   | \    \        /  |   \                      /|\   
+   |  \    \      /   |    \                    / | \    
+   |   \    \   1D   2D    3D                  /  |  \    
+   |    \    \  / \   |\   | \________________/__ |   \             
+   |     \    \/   \  | \__|_____________    /   \|    \             
+   |      \    \    \_|____|__           \  /     |     \            
+   |       \ /  \___  |    |  \           \/      |\     \              
+   |        /       \ |    |   \          /\      | \     \             
+   |       / \       \|    |    \        /  \     |  \     \              
+   |      /   \      /\    |     \      /    \    |   \     |              
+   |     /     \    /  \   |      \    /      \   |    \    |               
+   |    /       \  /    \  |       \  /        \  |     \   |                 
+   |   /         \/      \ |        \/          \ |      \  |               
+ OnePair1D   OnePair2D  OnePair3D  TwoPair1D  TwoPair2D TwoPair3D
+
+
 
  four particle functions are intendent to be resolution functions:
  it is mecessary to have simulated particle pair corresponding to given
@@ -24,6 +31,8 @@ Base classes for HBT functions
  and recontructed value to be further histogrammed
  
 */
+/////////////////////////////////////////////////////////////////////// 
+
 /******************************************************************/
 /******************************************************************/
 
@@ -144,6 +153,16 @@ void AliHBTFunction::Rename(const Char_t * name, const Char_t * title)
 
 
  }
+/******************************************************************/
+
+void AliHBTFunction::Init()
+{
+//Iniotializes fctn.: Resets histograms
+//In case histograms are not created in ctor, builds with default parameters
+  if ( !(GetNumerator()&&GetDenominator()) ) BuildHistos();
+  GetNumerator()->Reset();
+  GetDenominator()->Reset();
+}
 
 /******************************************************************/
 /******************************************************************/
@@ -161,85 +180,99 @@ ClassImp( AliHBTTwoPairFctn)
 /******************************************************************/
 /******************************************************************/
 
-ClassImp( AliHBTOnePairFctn1D )
-AliHBTOnePairFctn1D::AliHBTOnePairFctn1D():fNBinsToScale(30)
- {
-   fNumerator = 0x0;
-   fDenominator = 0x0;
- }
+ClassImp( AliHBTFunction1D )
 
-AliHBTOnePairFctn1D::
-AliHBTOnePairFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
- {
+const Int_t AliHBTFunction1D::fgkDefaultNBins = 100;
+const Float_t AliHBTFunction1D::fgkDefaultMin = 0.0;
+const Float_t AliHBTFunction1D::fgkDefaultMax = 0.15;
+const UInt_t AliHBTFunction1D::fgkDefaultNBinsToScale = 30;
+
+
+AliHBTFunction1D::AliHBTFunction1D():
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScale(fgkDefaultNBinsToScale)
+{
+}
+/******************************************************************/
+
+AliHBTFunction1D::AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval):
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScale(fgkDefaultNBinsToScale)
+{
  //Constructor of Two Part One Dimentional Function 
  // nbins: number of bins in histograms - default 100
  // maxXval and minXval: range of histgram(s) default 0 - 0.15 (GeV)
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
-   fDenominator = new TH1D(denstr.Data(),denstr.Data(),nbins,minXval,maxXval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
-   
-   fNBinsToScale = 30;
-   
- }
-AliHBTOnePairFctn1D::
-AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
-                    Int_t nbins, Double_t maxXval, Double_t minXval)
-       :AliHBTOnePairFctn(name,title)
+ BuildHistos(nbins,maxXval,minXval);
+}
+/******************************************************************/
+AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title):
+ AliHBTFunction(name,title),
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScale(fgkDefaultNBinsToScale)
 {
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
-   fDenominator = new TH1D(denstr.Data(),denstr.Data(),nbins,minXval,maxXval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
-   
-   fNBinsToScale = 30;
 }
 /******************************************************************/
-AliHBTOnePairFctn1D::~AliHBTOnePairFctn1D()
+AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title,
+                                   Int_t nbins, Float_t maxXval, Float_t minXval):
+ AliHBTFunction(name,title),
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScale(fgkDefaultNBinsToScale)
+{
+   BuildHistos(nbins,maxXval,minXval);
+}
+/******************************************************************/
+
+AliHBTFunction1D::~AliHBTFunction1D()
 {
   delete fNumerator;
   delete fDenominator;
 }
+/******************************************************************/
+void AliHBTFunction1D::BuildHistos()
+{
+ BuildHistos(fgkDefaultNBins,fgkDefaultMax,fgkDefaultMin);
+}
+
 /******************************************************************/
 
-void AliHBTOnePairFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
+void AliHBTFunction1D::BuildHistos(Int_t nbins, Float_t max, Float_t min)
 {
- //Fills the numerator
-   pair = CheckPair(pair);
-   if(pair) fNumerator->Fill(GetValue(pair));
+  TString numstr = fName + " Numerator";  //title and name of the 
+                                          //numerator histogram
+  TString denstr = fName + " Denominator";//title and name of the 
+                                          //denominator histogram
+  fNumerator   = new TH1D(numstr.Data(),numstr.Data(),nbins,min,max);
+  fDenominator = new TH1D(denstr.Data(),denstr.Data(),nbins,min,max);
+   
+  fNumerator->Sumw2();
+  fDenominator->Sumw2();
 }
 /******************************************************************/
-void AliHBTOnePairFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
- {
-  //fills denumerator
-   pair = CheckPair(pair);
-   if(pair) fDenominator->Fill(GetValue(pair));
 
-  }
+Double_t AliHBTFunction1D::Scale()
+{
+ //Calculates the factor that should be used to scale 
+ //quatience of fNumerator and fDenominator to 1 at tail
+ return Scale(fNumerator,fDenominator);
+}
 /******************************************************************/
-Double_t AliHBTOnePairFctn1D::Scale()
+
+Double_t AliHBTFunction1D::Scale(TH1D* num,TH1D* den)
 {
+ //Calculates the factor that should be used to scale 
+ //quatience of num and den to 1 at tail
   if (gDebug>0) Info("Scale","Enetered Scale()");
-  if(!fNumerator
+  if(!num
    {
      Error("Scale","No numerator");
      return 0.0;
    }
-  if(!fDenominator
+  if(!den
    {
      Error("Scale","No denominator");
      return 0.0;
@@ -250,7 +283,7 @@ Double_t AliHBTOnePairFctn1D::Scale()
     return 0.0;
     Error("Scale","Number of bins for scaling is smaller thnan 1");
    }
-  Int_t nbins = fNumerator->GetNbinsX();
+  UInt_t nbins = num->GetNbinsX();
   if (fNBinsToScale > nbins) 
    {
     Error("Scale","Number of bins for scaling is bigger thnan number of bins in histograms");
@@ -263,12 +296,12 @@ Double_t AliHBTOnePairFctn1D::Scale()
   Int_t N = 0;
   
   Int_t offset = nbins - fNBinsToScale - 1; 
-  Int_t i;
+  UInt_t i;
   for ( i = offset; i< nbins; i++)
    {
-    if ( fNumerator->GetBinContent(i) > 0.0 )
+    if ( num->GetBinContent(i) > 0.0 )
      {
-       ratio = fDenominator->GetBinContent(i)/fNumerator->GetBinContent(i);
+       ratio = den->GetBinContent(i)/num->GetBinContent(i);
        sum += ratio;
        N++;
      }
@@ -287,174 +320,264 @@ Double_t AliHBTOnePairFctn1D::Scale()
 /******************************************************************/
 /******************************************************************/
 
-ClassImp( AliHBTOnePairFctn2D )
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction2D                                  //
+//                                                   //
+// Base Calss for 2-dimensinal Functions             //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
 
-AliHBTOnePairFctn2D::
-AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval , 
-                    Int_t nYbins, Double_t maxYval, Double_t minYval)
+ClassImp( AliHBTFunction1D )
 
+const Int_t AliHBTFunction2D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
+const Float_t AliHBTFunction2D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
+const Float_t AliHBTFunction2D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
+
+const Int_t AliHBTFunction2D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
+const Float_t AliHBTFunction2D::fgkDefaultMinY = -0.15;//Default min value of histograms
+const Float_t AliHBTFunction2D::fgkDefaultMaxY =  0.15;//Default max value of histograms
+
+const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
+const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
+
+/******************************************************************/
+AliHBTFunction2D::AliHBTFunction2D():
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
+ fNBinsToScaleY(fgkDefaultNBinsToScaleY)
+{//default constructor
+}
+/******************************************************************/
+AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title):
+ AliHBTFunction(name,title),
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
+ fNBinsToScaleY(fgkDefaultNBinsToScaleY)
+{//constructor
+}
+/******************************************************************/
+
+AliHBTFunction2D::AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
+                                   Int_t nYbins, Double_t maxYval, Double_t minYval):
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
+ fNBinsToScaleY(fgkDefaultNBinsToScaleY)
 {
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH2D(numstr.Data(),numstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval);
-              
-   fDenominator = new TH2D(denstr.Data(),denstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
+  BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
+}        
+/******************************************************************/
 
+AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title,
+                                   Int_t nXbins, Double_t maxXval, Double_t minXval,
+                                   Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTFunction(name,title),
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
+ fNBinsToScaleY(fgkDefaultNBinsToScaleY)
+{
+  BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
 }        
-AliHBTOnePairFctn2D::~AliHBTOnePairFctn2D()
+/******************************************************************/
+
+AliHBTFunction2D::~AliHBTFunction2D()
 {
   delete fNumerator;
   delete fDenominator;
 }
-void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
+/******************************************************************/
+
+void AliHBTFunction2D::BuildHistos()
 {
-  pair = CheckPair(pair);
-  if(pair) 
-   { 
-     Double_t x,y;
-     GetValues(pair,x,y);
-     fNumerator->Fill(x,y);
-   }
+//Creates default histograms
+  BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
+              fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY);
 }
+/******************************************************************/
 
-void AliHBTOnePairFctn2D::ProcessDiffEventParticles(AliHBTPair* pair)
+void AliHBTFunction2D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
+                                   Int_t nybins, Float_t ymax, Float_t ymin)
 {
-  pair = CheckPair(pair);
-  if(pair) 
-   { 
-     Double_t x,y;
-     GetValues(pair,x,y);
-     fDenominator->Fill(x,y);
-   }
+ TString numstr = fName + " Numerator";  //title and name of the 
+                                           //numerator histogram
+ TString denstr = fName + " Denominator";//title and name of the 
+                                           //denominator histogram
+         
+ fNumerator   = new TH2D(numstr.Data(),numstr.Data(),
+                         nxbins,xmin,xmax,nybins,ymin,ymax);
+              
+ fDenominator = new TH2D(denstr.Data(),denstr.Data(),
+                         nxbins,xmin,xmax,nybins,ymin,ymax);
+ fNumerator->Sumw2();
+ fDenominator->Sumw2();
+}
+/******************************************************************/
 
+void AliHBTFunction2D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn)
+{
+//defines area used for scaling factor calculation
+  fNBinsToScaleX = xn;
+  fNBinsToScaleY = yn;
 }
+/******************************************************************/
 
+Double_t AliHBTFunction2D::Scale()
+{
+  if (gDebug>0) Info("Scale","Enetered Scale()");
+  if(!fNumerator) 
+   {
+     Error("Scale","No numerator");
+     return 0.0;
+   }
+  if(!fDenominator) 
+   {
+     Error("Scale","No denominator");
+     return 0.0;
+   }
+  
+  if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) ) 
+   {
+    return 0.0;
+    Error("Scale","Number of bins for scaling is smaller thnan 1");
+   }
+  UInt_t nbinsX = fNumerator->GetNbinsX();
+  if (fNBinsToScaleX > nbinsX) 
+   {
+    Error("Scale","Number of X bins for scaling is bigger thnan number of bins in histograms");
+    return 0.0;
+   }
+   
+  UInt_t nbinsY = fNumerator->GetNbinsX();
+  if (fNBinsToScaleY > nbinsY) 
+   {
+    Error("Scale","Number of Y bins for scaling is bigger thnan number of bins in histograms");
+    return 0.0;
+   }
+
+  if (gDebug>0) Info("Scale","No errors detected");
+
+  Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
+  Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis X
+
+  Double_t ratio;
+  Double_t sum = 0;
+  Int_t N = 0;
+  
+  UInt_t i,j;
+  for ( j = offsetY; j< nbinsY; j++)
+    for ( i = offsetX; i< nbinsX; i++)
+     {
+      if ( fNumerator->GetBinContent(i,j) > 0.0 )
+       {
+         ratio = fDenominator->GetBinContent(i,j)/fNumerator->GetBinContent(i,j);
+         sum += ratio;
+         N++;
+       }
+     }
+  
+  if(gDebug > 0) Info("Scale","sum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d N=%d",sum,fNBinsToScaleX,fNBinsToScaleY,N);
+  
+  if (N == 0) return 0.0;
+  Double_t ret = sum/((Double_t)N);
+
+  if(gDebug > 0) Info("Scale","returning %f",ret);
+  return ret;
+} 
 
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
 
-ClassImp( AliHBTOnePairFctn3D)
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction3D                                  //
+//                                                   //
+// Base Calss for 3-dimensinal Functions             //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
 
-AliHBTOnePairFctn3D::
-AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
-                    Int_t nYbins, Double_t maxYval, Double_t minYval, 
-                    Int_t nZbins, Double_t maxZval, Double_t minZval)
+ClassImp( AliHBTFunction3D)
 
-{
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH3D(numstr.Data(),numstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval,
-              nZbins,minZval,maxZval);
-              
-   fDenominator = new TH3D(denstr.Data(),denstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval,
-              nZbins,minZval,maxZval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
+const Int_t AliHBTFunction3D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
+const Float_t AliHBTFunction3D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
+const Float_t AliHBTFunction3D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
 
+const Int_t AliHBTFunction3D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
+const Float_t AliHBTFunction3D::fgkDefaultMinY = -0.15;//Default min value of histograms
+const Float_t AliHBTFunction3D::fgkDefaultMaxY =  0.15;//Default max value of histograms
+
+const Int_t AliHBTFunction3D::fgkDefaultNBinsZ = 200;//default number of Bins in histograms
+const Float_t AliHBTFunction3D::fgkDefaultMinZ = -0.15;//Default min value of histograms
+const Float_t AliHBTFunction3D::fgkDefaultMaxZ =  0.15;//Default max value of histograms
+
+const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
+const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
+const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleZ = 30;//Default number of bins used for scaling to tale
+
+
+AliHBTFunction3D::AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                  Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                  Int_t nZbins, Double_t maxZval, Double_t minZval):
+ fNumerator(0x0),
+ fDenominator(0x0),
+ fNBinsToScaleX(fgkDefaultNBinsToScaleX), 
+ fNBinsToScaleY(fgkDefaultNBinsToScaleY),
+ fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
+{
 }        
 /******************************************************************/
 
-AliHBTOnePairFctn3D::~AliHBTOnePairFctn3D()
+AliHBTFunction3D::~AliHBTFunction3D()
 {
   delete fNumerator;
   delete fDenominator;
 }
 /******************************************************************/
 
-
-/******************************************************************/
-/******************************************************************/
+void AliHBTFunction3D::BuildHistos()
+{
+//Creates default histograms
+  BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
+              fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY,
+              fgkDefaultNBinsZ,fgkDefaultMaxZ,fgkDefaultMinZ);
+}
 /******************************************************************/
-ClassImp( AliHBTTwoPairFctn1D)
-
-AliHBTTwoPairFctn1D::
-AliHBTTwoPairFctn1D(Int_t nbins, Double_t maxval, Double_t minval)
- {
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH1D(numstr.Data(),numstr.Data(),
-                           nbins,minval,maxval);
-              
-   fDenominator = new TH1D(denstr.Data(),denstr.Data(),
-                           nbins,minval,maxval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
-   fNBinsToScale = 30;
- }
 
-AliHBTTwoPairFctn1D::
-AliHBTTwoPairFctn1D(const Char_t* name, const Char_t* title,
-                    Int_t nbins, Double_t maxval, Double_t minval)
-       :AliHBTTwoPairFctn(name,title)
- {
+void AliHBTFunction3D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
+                                   Int_t nybins, Float_t ymax, Float_t ymin,
+                      Int_t nzbins, Float_t zmax, Float_t zmin)
+{
    TString numstr = fName + " Numerator";  //title and name of the 
                                            //numerator histogram
    TString denstr = fName + " Denominator";//title and name of the 
                                            //denominator histogram
          
-   fNumerator   = new TH1D(numstr.Data(),numstr.Data(),
-                           nbins,minval,maxval);
+   fNumerator   = new TH3D(numstr.Data(),numstr.Data(),
+                           nxbins,xmin,xmin,nybins,ymin,ymin,nzbins,zmin,zmin);
               
-   fDenominator = new TH1D(denstr.Data(),denstr.Data(),
-                           nbins,minval,maxval);
+   fDenominator = new TH3D(denstr.Data(),denstr.Data(),
+                           nxbins,xmin,xmin,nybins,ymin,ymin,nzbins,zmin,zmin);
    
    fNumerator->Sumw2();
    fDenominator->Sumw2();
-   fNBinsToScale = 30;
- }
-
-
-/******************************************************************/
-AliHBTTwoPairFctn1D::~AliHBTTwoPairFctn1D()
-{
-  delete fNumerator;
-  delete fDenominator;
-}
-void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
-{
-  partpair  = CheckPair(partpair);
-  if( partpair ) 
-   { 
-     Double_t x = GetValue(trackpair,partpair);
-     fNumerator->Fill(x);
-   }
 }
-/******************************************************************/
 
-void AliHBTTwoPairFctn1D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
-{
-  partpair  = CheckPair(partpair);
-  if( partpair )
-   { 
-     Double_t x = GetValue(trackpair,partpair);
-     fDenominator->Fill(x);
-   }
-}
 /******************************************************************/
-Double_t AliHBTTwoPairFctn1D::Scale()
+
+Double_t AliHBTFunction3D::Scale()
 {
   if (gDebug>0) Info("Scale","Enetered Scale()");
   if(!fNumerator) 
@@ -468,36 +591,58 @@ Double_t AliHBTTwoPairFctn1D::Scale()
      return 0.0;
    }
   
-  if(fNBinsToScale < 1
+  if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) || (fNBinsToScaleZ < 1)
    {
     return 0.0;
     Error("Scale","Number of bins for scaling is smaller thnan 1");
    }
-  Int_t nbins = fNumerator->GetNbinsX();
-  if (fNBinsToScale > nbins
+  UInt_t nbinsX = fNumerator->GetNbinsX();
+  if (fNBinsToScaleX > nbinsX
    {
-    Error("Scale","Number of bins for scaling is bigger thnan number of bins in histograms");
+    Error("Scale","Number of X bins for scaling is bigger thnan number of bins in histograms");
+    return 0.0;
+   }
+   
+  UInt_t nbinsY = fNumerator->GetNbinsX();
+  if (fNBinsToScaleY > nbinsY) 
+   {
+    Error("Scale","Number of Y bins for scaling is bigger thnan number of bins in histograms");
+    return 0.0;
+   }
+
+  UInt_t nbinsZ = fNumerator->GetNbinsZ();
+  if (fNBinsToScaleZ > nbinsZ) 
+   {
+    Error("Scale","Number of Z bins for scaling is bigger thnan number of bins in histograms");
     return 0.0;
    }
+
   if (gDebug>0) Info("Scale","No errors detected");
 
+  Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
+  Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis X
+  Int_t offsetZ = nbinsZ - fNBinsToScaleZ - 1; //bin that we start loop over bins in axis X
+
   Double_t ratio;
   Double_t sum = 0;
   Int_t N = 0;
   
-  Int_t offset = nbins - fNBinsToScale - 1; 
-  Int_t i;
-  for ( i = offset; i< nbins; i++)
-   {
-    if ( fNumerator->GetBinContent(i) > 0.0 )
-     {
-       ratio = fDenominator->GetBinContent(i)/fNumerator->GetBinContent(i);
-       sum += ratio;
-       N++;
-     }
-   }
+  UInt_t i,j,k;
+  for ( j = offsetZ; j< nbinsZ; j++)
+    for ( j = offsetY; j< nbinsY; j++)
+      for ( i = offsetX; i< nbinsX; i++)
+       {
+        if ( fNumerator->GetBinContent(i,j,k) > 0.0 )
+         {
+           ratio = fDenominator->GetBinContent(i,j,k)/fNumerator->GetBinContent(i,j,k);
+           sum += ratio;
+           N++;
+         }
+       }
   
-  if(gDebug > 0) Info("Scale","sum=%f fNBinsToScale=%d N=%d",sum,fNBinsToScale,N);
+  if(gDebug > 0) 
+    Info("Scale","sum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d fNBinsToScaleZ=%d N=%d",
+          sum,fNBinsToScaleX,fNBinsToScaleY,fNBinsToScaleZ,N);
   
   if (N == 0) return 0.0;
   Double_t ret = sum/((Double_t)N);
@@ -509,38 +654,298 @@ Double_t AliHBTTwoPairFctn1D::Scale()
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
-ClassImp( AliHBTTwoPairFctn2D)
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
 
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn1D                               //
+//                                                   //
+// Base Calss for 1-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
 
-AliHBTTwoPairFctn2D::
-AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval , 
-                    Int_t nYbins, Double_t maxYval, Double_t minYval)
+ClassImp( AliHBTOnePairFctn1D )
+/******************************************************************/
 
+AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
+ AliHBTFunction1D(nbins,maxXval,minXval)
 {
-   TString numstr = fName + " Numerator";  //title and name of the 
-                                           //numerator histogram
-   TString denstr = fName + " Denominator";//title and name of the 
-                                           //denominator histogram
-         
-   fNumerator   = new TH2D(numstr.Data(),numstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval);
-              
-   fDenominator = new TH2D(denstr.Data(),denstr.Data(),
-                           nXbins,minXval,maxXval,
-              nYbins,minYval,maxYval);
-   
-   fNumerator->Sumw2();
-   fDenominator->Sumw2();
+}
+/******************************************************************/
 
-}        
-AliHBTTwoPairFctn2D::~AliHBTTwoPairFctn2D()
+AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title):
+ AliHBTFunction1D(name,title)
+{
+}
+/******************************************************************/
+
+AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
+                                         Int_t nbins, Float_t maxXval, Float_t minXval):
+ AliHBTFunction1D(name,title,nbins,maxXval,minXval)
+{
+}
+/******************************************************************/
+
+void AliHBTOnePairFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
+{
+ //Fills the numerator
+   pair = CheckPair(pair);
+   if(pair) fNumerator->Fill(GetValue(pair));
+}
+/******************************************************************/
+void AliHBTOnePairFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
+ {
+  //fills denumerator
+   pair = CheckPair(pair);
+   if(pair) fDenominator->Fill(GetValue(pair));
+  }
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn2D                               //
+//                                                   //
+// Base Calss for 2-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+ClassImp( AliHBTOnePairFctn2D )
+/******************************************************************/
+
+AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title):
+ AliHBTFunction2D(name,title)
+{
+}
+/******************************************************************/
+
+AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
+{
+}
+/******************************************************************/
+
+AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTFunction2D(name,title, nXbins, maxXval, minXval, nYbins, maxYval, minYval)
+{
+}
+/******************************************************************/
+
+void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
+{
+  pair = CheckPair(pair);
+  if(pair) 
+   { 
+     Double_t x,y;
+     GetValues(pair,x,y);
+     fNumerator->Fill(x,y);
+   }
+}
+/******************************************************************/
+
+void AliHBTOnePairFctn2D::ProcessDiffEventParticles(AliHBTPair* pair)
+{
+  pair = CheckPair(pair);
+  if(pair) 
+   { 
+     Double_t x,y;
+     GetValues(pair,x,y);
+     fDenominator->Fill(x,y);
+   }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn3D                               //
+//                                                   //
+// Base Calss for 3-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+ClassImp( AliHBTOnePairFctn3D)
+
+/******************************************************************/
+
+AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title):
+ AliHBTFunction3D(name,title)
 {
-  delete fNumerator;
-  delete fDenominator;
 }
-void AliHBTTwoPairFctn2D::
-ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+/******************************************************************/
+
+AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval):
+ AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
+{
+}
+/******************************************************************/
+
+AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval):
+ AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
+{
+}
+/******************************************************************/
+
+void AliHBTOnePairFctn3D::ProcessSameEventParticles(AliHBTPair* pair)
+{
+//Reacts on pair coming from same event (real pairs)
+//and fills numerator histogram
+  pair  = CheckPair(pair);
+  if( pair ) 
+   { 
+     Double_t x,y,z;
+     GetValues(pair,x,y,z);
+     fNumerator->Fill(x,y,z);
+   }
+}
+/******************************************************************/
+
+void AliHBTOnePairFctn3D::ProcessDiffEventParticles(AliHBTPair* pair)
+{
+//Reacts on pair coming from different events (mixed pairs)
+//and fills denominator histogram
+  pair  = CheckPair(pair);
+  if( pair ) 
+   { 
+     Double_t x,y,z;
+     GetValues(pair,x,y,z);
+     fDenominator->Fill(x,y,z);
+   }
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn1D                               //
+//                                                   //
+// Base Calss for 1-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+ClassImp(AliHBTTwoPairFctn1D)
+/******************************************************************/
+
+AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
+ AliHBTFunction1D(nbins,maxXval,minXval)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title):
+ AliHBTFunction1D(name,title)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
+                                         Int_t nbins, Float_t maxXval, Float_t minXval):
+ AliHBTFunction1D(name,title,nbins,maxXval,minXval)
+{
+}
+/******************************************************************/
+
+void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  partpair  = CheckPair(partpair);
+  if( partpair ) 
+   { 
+     Double_t x = GetValue(trackpair,partpair);
+     fNumerator->Fill(x);
+   }
+}
+/******************************************************************/
+
+void AliHBTTwoPairFctn1D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  partpair  = CheckPair(partpair);
+  if( partpair )
+   { 
+     Double_t x = GetValue(trackpair,partpair);
+     fDenominator->Fill(x);
+   }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn2D                               //
+//                                                   //
+// Base Calss for 2-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+ClassImp(AliHBTTwoPairFctn2D)
+
+/******************************************************************/
+
+AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title):
+ AliHBTFunction2D(name,title)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTFunction2D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval)
+{
+}
+/******************************************************************/
+
+void AliHBTTwoPairFctn2D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
   partpair  = CheckPair(partpair);
   if( partpair ) 
@@ -550,9 +955,9 @@ ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
      fNumerator->Fill(x,y);
    }
 }
+/******************************************************************/
 
-void AliHBTTwoPairFctn2D::
-ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTTwoPairFctn2D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
   partpair  = CheckPair(partpair);
   if( partpair ) 
@@ -567,10 +972,49 @@ ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn3D                               //
+//                                                   //
+// Base Calss for 3-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
 ClassImp(AliHBTTwoPairFctn3D)
 
-void AliHBTTwoPairFctn3D::
-ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+/******************************************************************/
+
+AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title):
+ AliHBTFunction3D(name,title)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval):
+ AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
+{
+}
+/******************************************************************/
+
+AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval):
+ AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
+{
+}
+/******************************************************************/
+
+void AliHBTTwoPairFctn3D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
   partpair  = CheckPair(partpair);
   if( partpair ) 
@@ -580,9 +1024,9 @@ ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
      fNumerator->Fill(x,y,z);
    }
 }
+/******************************************************************/
 
-void AliHBTTwoPairFctn3D::
-ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTTwoPairFctn3D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
   partpair  = CheckPair(partpair);
   if( partpair ) 
@@ -594,3 +1038,8 @@ ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 
 }
 
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
index df22f2912ef97a3ee72a93de1551ed3c70eb61ba..4759953e48067cf448fe5941e122fcfb6bd7912d 100644 (file)
 #include <TH2.h>
 #include <TH3.h>
 
-
 class AliHBTAnalysis;
 
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction                                    //
+//                                                   //
+// Abstract Base Calss for all the function classes  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
 class AliHBTFunction: public TNamed
-//Abstract base class for HBT functions
 {
   public:
     AliHBTFunction();
     AliHBTFunction(const char* name,const char* title);
     virtual ~AliHBTFunction();
     
-    virtual TH1* GetNumerator() =0;
-    virtual TH1* GetDenominator() =0;
+    virtual TH1* GetNumerator() const = 0;
+    virtual TH1* GetDenominator() const = 0;
     virtual TH1* GetResult() = 0;
 
     virtual void Write();
+    virtual void Init();
     
     TH1* GetRatio(Double_t normfactor = 1.0);
     void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
@@ -36,11 +47,11 @@ class AliHBTFunction: public TNamed
     virtual AliHBTPair* CheckPair(AliHBTPair* pair);
     
   protected:
-    
+    virtual void BuildHistos() = 0;//builds default histograms
     AliHBTPairCut*      fPairCut;
     
   public:  
-   ClassDef(AliHBTFunction,1)
+   ClassDef(AliHBTFunction,2)
 };
 /******************************************************************/
 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
@@ -61,221 +72,525 @@ inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
-class AliHBTOnePairFctn: public AliHBTFunction
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn                                 //
+//                                                   //
+// Abstract Base Calss for Functions that need       //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTOnePairFctn
 {
   public:
     AliHBTOnePairFctn(){}
-    AliHBTOnePairFctn(const Char_t *name, const Char_t *title):AliHBTFunction(name,title){}
     virtual ~AliHBTOnePairFctn(){}
     
     virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
 
-
+    virtual void Init() = 0;
+    virtual void Write() = 0;
     
   protected:
   public:  
-   ClassDef(AliHBTOnePairFctn,1)
+   ClassDef(AliHBTOnePairFctn,2)
   
 };
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
-class AliHBTTwoPairFctn: public AliHBTFunction
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn                                 //
+//                                                   //
+// Abstract Base Calss for Functions that need       //
+// two pairs to fill function,                       //
+// one reconstructed track and corresponding         //
+// simulated pair                                    //
+// Basically resolution functions                    //
+// Lednicky's algorithm uses that as well            //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTTwoPairFctn
 {
   public:
     AliHBTTwoPairFctn(){};
-    AliHBTTwoPairFctn(const Char_t *name, const Char_t *title):AliHBTFunction(name,title){}
     virtual ~AliHBTTwoPairFctn(){};
     
     virtual void 
     ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
     virtual void 
     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
-
+    
+    virtual void Init() = 0;
+    virtual void Write() = 0;
             
   protected:
   public:  
-   ClassDef(AliHBTTwoPairFctn,1)
+   ClassDef(AliHBTTwoPairFctn,2)
   
 };
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
 
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction1D                                  //
+//                                                   //
+// Base Calss for 1-dimensinal Functions             //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
 
-class AliHBTOnePairFctn1D: public AliHBTOnePairFctn
+
+class AliHBTFunction1D: public AliHBTFunction
 {
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBins;//default number of Bins in histograms
+  static const Float_t fgkDefaultMin;//Default min value of histograms
+  static const Float_t fgkDefaultMax;//Default max value of histograms
+  static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
+
  public:
-  AliHBTOnePairFctn1D();
-  AliHBTOnePairFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
-  AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
-                      Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
-  virtual ~AliHBTOnePairFctn1D();
-  
+  AliHBTFunction1D();//default conmstructor
+  AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
+  AliHBTFunction1D(const Char_t *name, const Char_t *title);
+  AliHBTFunction1D(const Char_t *name, const Char_t *title,
+                   Int_t nbins, Float_t maxXval, Float_t minXval);
+  virtual ~AliHBTFunction1D();
   
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
+  TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
+  TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
+
+  Double_t Scale();
+  void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
 
-  void ProcessSameEventParticles(AliHBTPair* pair);
-  void ProcessDiffEventParticles(AliHBTPair* pair);
-  Double_t Scale();  
-  void SetNumberOfBinsToScale(Int_t n = 30){fNBinsToScale = n;}
  protected:
   //retruns velue to be histogrammed
-  virtual Double_t GetValue(AliHBTPair* pair) = 0; 
-
+  virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
+  virtual void BuildHistos();
+  Double_t Scale(TH1D* num,TH1D* den);
+  
   TH1D* fNumerator;
   TH1D* fDenominator;
-  Int_t fNBinsToScale;
-  
+  UInt_t fNBinsToScale;
+
  public:
-  ClassDef(AliHBTOnePairFctn1D,2)
+  ClassDef(AliHBTFunction1D,2)
 };
 
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction2D                                  //
+//                                                   //
+// Base Calss for 2-dimensinal Functions             //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
  
-class AliHBTOnePairFctn2D: public AliHBTOnePairFctn
+class AliHBTFunction2D: public AliHBTFunction
 {
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
+  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
+  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
+  static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
+  static const Float_t fgkDefaultMinY;//Default min value of histograms
+  static const Float_t fgkDefaultMaxY;//Default max value of histograms
+
+  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
+
  public:
-  AliHBTOnePairFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
-                      Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
-  virtual ~AliHBTOnePairFctn2D();
+  AliHBTFunction2D();
+
+  AliHBTFunction2D(const Char_t *name, const Char_t *title);
+
+  AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+
+  AliHBTFunction2D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+         
+  virtual ~AliHBTFunction2D();
   
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
+  TH1* GetNumerator() const {return fNumerator;}
+  TH1* GetDenominator() const {return fDenominator;}
   
-  void ProcessSameEventParticles(AliHBTPair* pair);
-  void ProcessDiffEventParticles(AliHBTPair* pair);
-
+  void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, 
+                              UInt_t yn = fgkDefaultNBinsToScaleY);
+  
+  Double_t Scale();
  protected:
-  virtual void GetValues(AliHBTPair* pair, Double_t&, Double_t&) = 0;
-
+  virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
+                           Int_t nybins, Float_t ymax, Float_t ymin);
+  virtual void BuildHistos();
+  
   TH2D* fNumerator;
   TH2D* fDenominator;
   
+  //definition of area used for scaling -> Scale is calculated this 
+  //way that after division tale is on 1
+  UInt_t fNBinsToScaleX;//number of bins on X axis
+  UInt_t fNBinsToScaleY;//number of bins on Y axis
+
  public:
-  ClassDef(AliHBTOnePairFctn2D,1)
+  ClassDef(AliHBTFunction2D,2)
 };
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
 
-class AliHBTOnePairFctn3D: public AliHBTOnePairFctn
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTFunction3D                               //
+//                                                   //
+// Base Calss for 3-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTFunction3D: public AliHBTFunction
 {
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
+  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
+  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
+  static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
+  static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
+  static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
+  static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
+  static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
+  static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
+
+  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
+  
  public:
-  AliHBTOnePairFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
-                      Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15, 
-                      Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
-           
-  virtual ~AliHBTOnePairFctn3D();
+  AliHBTFunction3D();
+
+  AliHBTFunction3D(const Char_t *name, const Char_t *title);
+
+  AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                   Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                   Int_t nZbins, Double_t maxZval, Double_t minZval);
+
+  AliHBTFunction3D(const Char_t *name, const Char_t *title,
+                   Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                   Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                   Int_t nZbins, Double_t maxZval, Double_t minZval);
+   
+  virtual ~AliHBTFunction3D();//destructor
+
+  TH1* GetNumerator() const {return fNumerator;}
+  TH1* GetDenominator() const {return fDenominator;}
 
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
+
+  void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX, 
+                              UInt_t yn = fgkDefaultNBinsToScaleY,
+                              UInt_t zn = fgkDefaultNBinsToScaleZ);
+
+  Double_t Scale();
 
  protected:
+  virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
+                           Int_t nybins, Float_t ymax, Float_t ymin,
+              Int_t nzbins, Float_t zmax, Float_t zmin);
+  virtual void BuildHistos();
+  
   TH3D* fNumerator;
   TH3D* fDenominator;
+  
+  //definition of area used for scaling -> Scale is calculated this 
+  //way that after division tale is on 1
+  UInt_t fNBinsToScaleX;//number of bins on X axis
+  UInt_t fNBinsToScaleY;//number of bins on Y axis
+  UInt_t fNBinsToScaleZ;//number of bins on Z axis
+  
  public:
-  ClassDef(AliHBTOnePairFctn3D,1)
+  ClassDef(AliHBTFunction3D,2)
 };
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
 
-class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn1D                               //
+//                                                   //
+// Base Calss for 1-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
 {
  public:
-  AliHBTTwoPairFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
-  AliHBTTwoPairFctn1D(const char*,const char*,
-                      Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
-  virtual ~AliHBTTwoPairFctn1D();
-  
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
-  
-  void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  
-  Double_t Scale();  
-  void SetNumberOfBinsToScale(Int_t n = 30){fNBinsToScale = n;} 
+  AliHBTOnePairFctn1D(){}//default conmstructor
+  AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
+  AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title);
+  AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
+                      Int_t nbins, Float_t maxXval, Float_t minXval);
+  virtual ~AliHBTOnePairFctn1D(){}
+
+  void ProcessSameEventParticles(AliHBTPair* pair);
+  void ProcessDiffEventParticles(AliHBTPair* pair);
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
  protected:
-  virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
+  //retruns velue to be histogrammed
+  virtual Double_t GetValue(AliHBTPair* pair) = 0; 
+  ClassDef(AliHBTOnePairFctn1D,2)
+};
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
 
-  TH1D* fNumerator;
-  TH1D* fDenominator;
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn2D                               //
+//                                                   //
+// Base Calss for 2-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
+{
+ public:
+  AliHBTOnePairFctn2D(){}
 
-  Int_t fNBinsToScale;
+  AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
 
- public:
-  ClassDef(AliHBTTwoPairFctn1D,1)
+  AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+
+  AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+         
+  virtual ~AliHBTOnePairFctn2D(){}
+  
+  void ProcessSameEventParticles(AliHBTPair* pair);
+  void ProcessDiffEventParticles(AliHBTPair* pair);
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
+ protected:
+  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) = 0;
+  ClassDef(AliHBTOnePairFctn2D,2)
 };
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
 
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTOnePairFctn3D                               //
+//                                                   //
+// Base Calss for 3-dimensinal Functions that need   //
+// one pair to fill function                         //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
+{
+ public:
+  AliHBTOnePairFctn3D(){}
 
+  AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
+
+  AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval);
+
+  AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval);
+   
+  virtual ~AliHBTOnePairFctn3D(){}//destructor
+
+  void ProcessSameEventParticles(AliHBTPair* pair);
+  void ProcessDiffEventParticles(AliHBTPair* pair);
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
+ protected:
+  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) = 0;
+ ClassDef(AliHBTOnePairFctn3D,2)
+};
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
-class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn1D                               //
+//                                                   //
+// Base Calss for 1-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
 {
  public:
-  AliHBTTwoPairFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
-                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
-  virtual ~AliHBTTwoPairFctn2D();
-  
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
-  
+  AliHBTTwoPairFctn1D(){}//default conmstructor
+  AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
+  AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
+  AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
+                      Int_t nbins, Float_t maxXval, Float_t minXval);
+  virtual ~AliHBTTwoPairFctn1D(){}
+
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
  protected:
-  virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;
-
-  TH2D* fNumerator;
-  TH2D* fDenominator;
-  
- public:
-  ClassDef(AliHBTTwoPairFctn2D,1)
+  virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
+ public: 
+  ClassDef(AliHBTTwoPairFctn1D,2)
 };
-
-
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
-class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn
+
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn2D                               //
+//                                                   //
+// Base Calss for 2-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
 {
  public:
-  AliHBTTwoPairFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
-                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15, 
-                       Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
-  virtual ~AliHBTTwoPairFctn3D(){}
-  
-  TH1* GetNumerator(){return fNumerator;}
-  TH1* GetDenominator(){return fDenominator;}
+  AliHBTTwoPairFctn2D(){}
+
+  AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
+
+  AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+
+  AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval);
+         
+  virtual ~AliHBTTwoPairFctn2D(){}
   
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
+
  protected:
-  virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&,Double_t&) = 0;
+  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) = 0;
 
-  TH3D* fNumerator;
-  TH3D* fDenominator;
-  
  public:
-  ClassDef(AliHBTTwoPairFctn3D,1)
+  ClassDef(AliHBTTwoPairFctn2D,2)
 };
-
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
 
+//____________________
+///////////////////////////////////////////////////////
+//                                                   //
+// AliHBTTwoPairFctn3D                               //
+//                                                   //
+// Base Calss for 3-dimensinal Functions that need   //
+// two pair (simulated and reconstructed)            //
+// to fill function                                  //
+//                                                   //
+// Piotr.Skowronski@cern.ch                          //
+// http://alisoft.cern.ch/people/skowron/analyzer    //
+//                                                   //
+///////////////////////////////////////////////////////
+
+class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
+{
+ public:
+  AliHBTTwoPairFctn3D(){}
+  
+  AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
+
+  AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval);
+
+  AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
+                      Int_t nXbins, Double_t maxXval, Double_t minXval, 
+                      Int_t nYbins, Double_t maxYval, Double_t minYval, 
+                      Int_t nZbins, Double_t maxZval, Double_t minZval);
+   
+  virtual ~AliHBTTwoPairFctn3D(){}//destructor
 
+  void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+  void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+  void Write(){AliHBTFunction::Write();}
+  void Init(){AliHBTFunction::Init();}
+
+ protected:
+  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) = 0;
+
+ public:
+  ClassDef(AliHBTTwoPairFctn3D,2)
+};
 
 #endif
index cbca1e64de638a42b8bbab18a182902675883980..f5b5d68b00e0fe2e58adb7722f00484c548b892d 100644 (file)
 #pragma link C++ class AliHBTFunction+;
 #pragma link C++ class AliHBTMonitorFunction+;
 
+#pragma link C++ class AliHBTFunction1D+;
+#pragma link C++ class AliHBTFunction2D+;
+#pragma link C++ class AliHBTFunction3D+;
+
 #pragma link C++ class AliHBTOnePairFctn+;
 #pragma link C++ class AliHBTOnePairFctn1D+;
 #pragma link C++ class AliHBTOnePairFctn2D+;
 #pragma link C++ class AliHBTLLWeightQInvFctn+;
 #pragma link C++ class AliHBTLLWeightTheorQInvFctn+;
 #pragma link C++ class AliHBTLLWeightsPID+;
+//#pragma link C++ class AliHBTCorrectQ3DCorrelFctn+;
+//#pragma link C++ class AliHBTCorrectQInvCorrelFctn+;
 #endif