From: skowron Date: Mon, 11 Nov 2002 10:22:54 +0000 (+0000) Subject: Function base classes redesign X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=26f1270c45394020e7625619e415725fd0e4de02 Function base classes redesign --- diff --git a/HBTAN/AliHBTFunction.cxx b/HBTAN/AliHBTFunction.cxx index 3a4228f3dd3..534f9685b90 100644 --- a/HBTAN/AliHBTFunction.cxx +++ b/HBTAN/AliHBTFunction.cxx @@ -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) } + +/******************************************************************/ +/******************************************************************/ +/******************************************************************/ + diff --git a/HBTAN/AliHBTFunction.h b/HBTAN/AliHBTFunction.h index df22f2912ef..4759953e480 100644 --- a/HBTAN/AliHBTFunction.h +++ b/HBTAN/AliHBTFunction.h @@ -10,22 +10,33 @@ #include #include - 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 diff --git a/HBTAN/HBTAnalysisLinkDef.h b/HBTAN/HBTAnalysisLinkDef.h index cbca1e64de6..f5b5d68b00e 100644 --- a/HBTAN/HBTAnalysisLinkDef.h +++ b/HBTAN/HBTAnalysisLinkDef.h @@ -11,6 +11,10 @@ #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+; @@ -138,4 +142,6 @@ #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