#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
and recontructed value to be further histogrammed
*/
+///////////////////////////////////////////////////////////////////////
+
/******************************************************************/
/******************************************************************/
}
+/******************************************************************/
+
+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();
+}
/******************************************************************/
/******************************************************************/
/******************************************************************/
/******************************************************************/
-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;
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");
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++;
}
/******************************************************************/
/******************************************************************/
-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)
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);
/******************************************************************/
/******************************************************************/
/******************************************************************/
-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 )
fNumerator->Fill(x,y);
}
}
+/******************************************************************/
-void AliHBTTwoPairFctn2D::
-ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTTwoPairFctn2D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
partpair = CheckPair(partpair);
if( 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 )
fNumerator->Fill(x,y,z);
}
}
+/******************************************************************/
-void AliHBTTwoPairFctn3D::
-ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTTwoPairFctn3D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
partpair = CheckPair(partpair);
if( partpair )
}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
#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
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)
/******************************************************************/
/******************************************************************/
/******************************************************************/
-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
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff