1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 #include "AliHBTFunction.h"
22 //--------------------------------------------------------------------
24 //Author: Piotr Krzysztof Skowronski
25 //Piotr.Skowronski@cern.ch
26 //Base classes for HBT functions
28 OnePairFctn Function TwoPairFctn
32 | \ \ / \ |\ | \________________/__ | \
33 | \ \/ \ | \__|_____________ / \| \
34 | \ \ \_|____|__ \ / | \
35 | \ / \___ | | \ \/ |\ \
37 | / \ \| | \ / \ | \ \
38 | / \ /\ | \ / \ | \ |
39 | / \ / \ | \ / \ | \ |
40 | / \ / \ | \ / \ | \ |
42 OnePair1D OnePair2D OnePair3D TwoPair1D TwoPair2D TwoPair3D
45 four particle functions are intendent to be resolution functions:
46 it is mecessary to have simulated particle pair corresponding to given
47 recontructed track pair in order to calculate function simualted value
48 and recontructed value, to be further histogrammed
50 //---------------------------------------------------------------------
55 /******************************************************************/
56 /******************************************************************/
58 ClassImp( AliHBTFunction )
60 AliHBTFunction::AliHBTFunction():
61 fPairCut(new AliAODPairEmptyCut()), //dummy cut
62 fWriteNumAndDen(kFALSE),
67 /******************************************************************/
69 AliHBTFunction::AliHBTFunction(const char* name,const char* title):
71 fPairCut(new AliAODPairEmptyCut()), //dummy cut
72 fWriteNumAndDen(kFALSE),
77 /******************************************************************/
79 AliHBTFunction::AliHBTFunction(const AliHBTFunction & source):
81 fPairCut((AliAODPairCut*)source.fPairCut->Clone()),
82 fWriteNumAndDen(source.fWriteNumAndDen),
85 // Copy constructor needed by the coding conventions
87 /******************************************************************/
89 AliHBTFunction::~AliHBTFunction()
92 AliDebug(1,"Deleting");
95 /******************************************************************/
96 AliHBTFunction & AliHBTFunction::operator= (const AliHBTFunction & source)
98 // Assignment needed by the coding conventions
100 fPairCut = (AliAODPairCut*)source.fPairCut->Clone();
105 Int_t AliHBTFunction::WriteFunction()
107 //writes result of the function to file
109 AliDebug(1,"Entering");
112 AliDebug(1,"Writing Num & Den");
113 if (GetNumerator()) GetNumerator()->Write();
114 if (GetDenominator()) GetDenominator()->Write();
115 AliDebug(1,"Writing Num & Den Done");
117 AliDebug(1,"Getting Result");
118 TH1* res = GetResult();
119 AliDebug(1,"Getting Result Done");
123 AliDebug(1,"Writing Result");
124 retval = res->Write();
125 AliDebug(1,"Writing Result Done");
129 /******************************************************************/
131 TH1* AliHBTFunction::GetRatio(Double_t normfactor)
133 //returns ratio of numerator and denominator
135 AliDebug(1,Form("Norm. Factor is %f for %s",normfactor,GetName()));
137 if (normfactor == 0.0)
139 AliError("Scaling Factor is 0. Null poiner returned");
142 TString str = fName + " ratio";
143 TH1 *result = (TH1*)GetNumerator()->Clone(str.Data());
144 result->SetDirectory(0x0);
146 result->SetTitle(str.Data());
148 result->Divide(GetNumerator(),GetDenominator(),normfactor);
153 /******************************************************************/
154 void AliHBTFunction::SetPairCut(AliAODPairCut* cut)
156 //Sets new Pair Cut. Old one is deleted
157 //Note that it is created new object instead of simple pointer set
158 //I do not want to have pointer
159 //to object created somewhere else
160 //because in that case I could not believe that
161 //it would always exist (sb could delete it)
162 //so we have always own copy
166 AliError("argument is NULL");
170 fPairCut = (AliAODPairCut*)cut->Clone();
174 /******************************************************************/
176 void AliHBTFunction::Rename(const Char_t * name)
178 //renames the function and histograms
182 TString numstr = fName + " Numerator"; //title and name of the
183 //numerator histogram
184 TString denstr = fName + " Denominator";//title and name of the
185 //denominator histogram
187 GetNumerator()->SetName(numstr.Data());
188 GetNumerator()->SetTitle(numstr.Data());
190 GetDenominator()->SetName(denstr.Data());
191 GetDenominator()->SetTitle(denstr.Data());
195 void AliHBTFunction::Rename(const Char_t * name, const Char_t * title)
197 //renames and retitle the function and histograms
202 TString numstrn = fName + " Numerator"; //name of the
203 //numerator histogram
205 TString numstrt = fTitle + " Numerator"; //title of the
206 //numerator histogram
208 TString denstrn = fName + " Denominator";//name of the
209 //denominator histogram
211 TString denstrt = fTitle + " Denominator";//title of the
212 //denominator histogram
215 GetNumerator()->SetName(numstrn.Data());
216 GetNumerator()->SetTitle(numstrt.Data());
218 GetDenominator()->SetName(denstrn.Data());
219 GetDenominator()->SetTitle(denstrt.Data());
223 /******************************************************************/
225 void AliHBTFunction::InitFunction()
227 //Iniotializes fctn.: Resets histograms
228 //In case histograms are not created in ctor, builds with default parameters
229 AliDebug(1,"Entering");
230 if ( !(GetNumerator()&&GetDenominator()) ) BuildHistos();
231 GetNumerator()->Reset();
232 GetDenominator()->Reset();
234 GetNumerator()->SetDirectory(0x0);
235 GetDenominator()->SetDirectory(0x0);
238 /******************************************************************/
239 /******************************************************************/
240 /******************************************************************/
241 ClassImp(AliHBTCorrelFunction)
242 //____________________________________________
243 //////////////////////////////////////////////
245 // class AliHBTCorrelFunction
247 // Base class for correlation fuctions, that is which returns ratio.
248 // Stores pointer the created ratio histogram and deletes it when function is deleted
249 // created in order to evoid memory leak
251 ////////////////////////////////////////////////////////
252 AliHBTCorrelFunction& AliHBTCorrelFunction::operator=(const AliHBTCorrelFunction& in)
255 if (&in == this) return *this;
257 fRatio=(in.fRatio)?(TH1*)in.fRatio->Clone():0x0;
258 fRatio->SetDirectory(0x0);
262 /******************************************************************/
263 /******************************************************************/
264 /******************************************************************/
266 ClassImp( AliHBTOnePairFctn )
268 /******************************************************************/
269 /******************************************************************/
270 /******************************************************************/
272 ClassImp( AliHBTTwoPairFctn)
274 /******************************************************************/
275 /******************************************************************/
276 /******************************************************************/
278 ClassImp( AliHBTFunction1D )
280 const Int_t AliHBTFunction1D::fgkDefaultNBins = 100;
281 const Float_t AliHBTFunction1D::fgkDefaultMin = 0.0;
282 const Float_t AliHBTFunction1D::fgkDefaultMax = 0.15;
283 const UInt_t AliHBTFunction1D::fgkDefaultNBinsToScale = 30;
286 AliHBTFunction1D::AliHBTFunction1D():
289 fNBinsToScale(fgkDefaultNBinsToScale)
290 {//default constructor
292 /******************************************************************/
294 AliHBTFunction1D::AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval):
297 fNBinsToScale(fgkDefaultNBinsToScale)
299 //Constructor of Two Part One Dimentional Function
300 // nbins: number of bins in histograms - default 100
301 // maxXval and minXval: range of histgram(s) default 0 - 0.15 (GeV)
302 BuildHistos(nbins,maxXval,minXval);
304 /******************************************************************/
305 AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title):
306 AliHBTFunction(name,title),
309 fNBinsToScale(fgkDefaultNBinsToScale)
312 /******************************************************************/
313 AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title,
314 Int_t nbins, Float_t maxXval, Float_t minXval):
315 AliHBTFunction(name,title),
318 fNBinsToScale(fgkDefaultNBinsToScale)
321 BuildHistos(nbins,maxXval,minXval);
323 /******************************************************************/
325 AliHBTFunction1D::AliHBTFunction1D(const AliHBTFunction1D& source):
326 AliHBTFunction(source)
328 // Copy constructor needed by the coding conventions byt not used
329 Fatal("AliHBTFunction1D(const AliHBTFunction1D&)","Cpy ctor not usable.");
331 /******************************************************************/
333 AliHBTFunction1D& AliHBTFunction1D::operator= (const AliHBTFunction1D & /*source*/)
335 // Assignment needed by the coding conventions byt not used
336 Fatal("Assignment operator","not implemented");
339 /******************************************************************/
341 AliHBTFunction1D::~AliHBTFunction1D()
347 /******************************************************************/
348 void AliHBTFunction1D::BuildHistos()
350 //builds histograms with default settings
351 BuildHistos(fgkDefaultNBins,fgkDefaultMax,fgkDefaultMin);
354 /******************************************************************/
356 void AliHBTFunction1D::BuildHistos(Int_t nbins, Float_t max, Float_t min)
358 //builds numarator and denominator hitograms
359 TString numstr = fName + " Numerator"; //title and name of the
360 //numerator histogram
361 TString denstr = fName + " Denominator";//title and name of the
362 //denominator histogram
363 fNumerator = new TH1D(numstr.Data(),numstr.Data(),nbins,min,max);
364 fDenominator = new TH1D(denstr.Data(),denstr.Data(),nbins,min,max);
367 fDenominator->Sumw2();
369 /******************************************************************/
371 Double_t AliHBTFunction1D::Scale()
373 //Calculates the factor that should be used to scale
374 //quatience of fNumerator and fDenominator to 1 at tail
375 return Scale(fNumerator,fDenominator);
377 /******************************************************************/
379 Double_t AliHBTFunction1D::Scale(TH1D* num,TH1D* den)
381 //Calculates the factor that should be used to scale
382 //quatience of num and den to 1 at tail
384 AliDebug(1,"Entered");
387 AliError("No numerator");
392 AliError("No denominator");
396 if(fNBinsToScale < 1)
398 AliError("Number of bins for scaling is smaller than 1");
401 UInt_t nbins = num->GetNbinsX();
402 if (fNBinsToScale > nbins)
404 AliError("Number of bins for scaling is bigger thnan number of bins in histograms");
407 AliDebug(1,"No errors detected");
409 Double_t densum = 0.0;
410 Double_t numsum = 0.0;
412 Int_t offset = nbins - fNBinsToScale - 1;
414 for (UInt_t i = offset; i< nbins; i++)
416 if ( num->GetBinContent(i) > 0.0 )
418 densum += den->GetBinContent(i);
419 numsum += num->GetBinContent(i);
423 AliDebug(1,Form("numsum=%f densum=%f fNBinsToScaleX=%d",numsum,densum,fNBinsToScale));
425 if (numsum == 0) return 0.0;
426 Double_t ret = densum/numsum;
428 AliDebug(1,Form("returning %f",ret));
432 /******************************************************************/
433 /******************************************************************/
434 /******************************************************************/
436 //____________________
437 ///////////////////////////////////////////////////////
439 // AliHBTFunction2D //
441 // Base Calss for 2-dimensinal Functions //
443 // Piotr.Skowronski@cern.ch //
444 // http://aliweb.cern.ch/people/skowron/analyzer //
446 ///////////////////////////////////////////////////////
448 ClassImp( AliHBTFunction2D )
450 const Int_t AliHBTFunction2D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
451 const Float_t AliHBTFunction2D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
452 const Float_t AliHBTFunction2D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
454 const Int_t AliHBTFunction2D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
455 const Float_t AliHBTFunction2D::fgkDefaultMinY = -0.15;//Default min value of histograms
456 const Float_t AliHBTFunction2D::fgkDefaultMaxY = 0.15;//Default max value of histograms
458 const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
459 const UInt_t AliHBTFunction2D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
461 /******************************************************************/
462 AliHBTFunction2D::AliHBTFunction2D():
465 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
466 fNBinsToScaleY(fgkDefaultNBinsToScaleY)
467 {//default constructor
469 /******************************************************************/
470 AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title):
471 AliHBTFunction(name,title),
474 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
475 fNBinsToScaleY(fgkDefaultNBinsToScaleY)
478 /******************************************************************/
480 AliHBTFunction2D::AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
481 Int_t nYbins, Double_t maxYval, Double_t minYval):
484 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
485 fNBinsToScaleY(fgkDefaultNBinsToScaleY)
487 BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
489 /******************************************************************/
491 AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title,
492 Int_t nXbins, Double_t maxXval, Double_t minXval,
493 Int_t nYbins, Double_t maxYval, Double_t minYval):
494 AliHBTFunction(name,title),
497 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
498 fNBinsToScaleY(fgkDefaultNBinsToScaleY)
500 BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
502 /******************************************************************/
503 AliHBTFunction2D::AliHBTFunction2D(const AliHBTFunction2D & source):
504 AliHBTFunction(source)
506 // Copy constructor needed by the coding conventions byt not used
507 Fatal("AliHBTFunction2D(const AliHBTFunction2D&)","Cpy ctor not usable.");
509 /******************************************************************/
511 AliHBTFunction2D& AliHBTFunction2D::operator= (const AliHBTFunction2D& /*source*/) {
512 // Assignment needed by the coding conventions byt not used
513 Fatal("Assignment operator","not implemented");
516 /******************************************************************/
518 AliHBTFunction2D::~AliHBTFunction2D()
524 /******************************************************************/
526 void AliHBTFunction2D::BuildHistos()
528 //Creates default histograms
529 BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
530 fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY);
532 /******************************************************************/
534 void AliHBTFunction2D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
535 Int_t nybins, Float_t ymax, Float_t ymin)
537 //Builds numerator and denominator histograms (2d-case)
538 TString numstr = fName + " Numerator"; //title and name of the
539 //numerator histogram
540 TString denstr = fName + " Denominator";//title and name of the
541 //denominator histogram
543 fNumerator = new TH2D(numstr.Data(),numstr.Data(),
544 nxbins,xmin,xmax,nybins,ymin,ymax);
546 fDenominator = new TH2D(denstr.Data(),denstr.Data(),
547 nxbins,xmin,xmax,nybins,ymin,ymax);
550 fDenominator->Sumw2();
552 /******************************************************************/
554 void AliHBTFunction2D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn)
556 //defines area used for scaling factor calculation
560 /******************************************************************/
562 Double_t AliHBTFunction2D::Scale()
564 // Calculates the factor that should be used to scale
565 // quatience of fNumerator and fDenominator to 1 at
567 AliDebug(1,"Entered");
570 AliError("No numerator");
575 AliError("No denominator");
579 if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) )
581 AliError("Number of bins for scaling is smaller thnan 1");
584 UInt_t nbinsX = fNumerator->GetNbinsX();
585 if (fNBinsToScaleX > nbinsX)
587 AliError("Number of X bins for scaling is bigger thnan number of bins in histograms");
591 UInt_t nbinsY = fNumerator->GetNbinsX();
592 if (fNBinsToScaleY > nbinsY)
594 AliError("Number of Y bins for scaling is bigger thnan number of bins in histograms");
598 AliDebug(1,"No errors detected");
600 Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
601 Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis X
603 Double_t densum = 0.0;
604 Double_t numsum = 0.0;
606 for (UInt_t j = offsetY; j< nbinsY; j++)
607 for (UInt_t i = offsetX; i< nbinsX; i++)
609 if ( fNumerator->GetBinContent(i,j) > 0.0 )
611 densum += fDenominator->GetBinContent(i,j);
612 numsum += fNumerator->GetBinContent(i,j);
616 AliDebug(1,Form("numsum=%f densum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d",
617 numsum,densum,fNBinsToScaleX,fNBinsToScaleY));
619 if (numsum == 0) return 0.0;
620 Double_t ret = densum/numsum;
622 AliDebug(1,Form("returning %f",ret));
626 /******************************************************************/
627 /******************************************************************/
628 /******************************************************************/
630 //____________________
631 ///////////////////////////////////////////////////////
633 // AliHBTFunction3D //
635 // Base Calss for 3-dimensinal Functions //
637 // Piotr.Skowronski@cern.ch //
638 // http://aliweb.cern.ch/people/skowron/analyzer //
640 ///////////////////////////////////////////////////////
642 ClassImp( AliHBTFunction3D)
644 const Int_t AliHBTFunction3D::fgkDefaultNBinsX = 200;//default number of Bins in X axis in histograms
645 const Float_t AliHBTFunction3D::fgkDefaultMinX = 0.0;//Default min value of X axis in histograms
646 const Float_t AliHBTFunction3D::fgkDefaultMaxX = 1.5;//Default max value of X axis inhistograms
648 const Int_t AliHBTFunction3D::fgkDefaultNBinsY = 200;//default number of Bins in histograms
649 const Float_t AliHBTFunction3D::fgkDefaultMinY = -0.15;//Default min value of histograms
650 const Float_t AliHBTFunction3D::fgkDefaultMaxY = 0.15;//Default max value of histograms
652 const Int_t AliHBTFunction3D::fgkDefaultNBinsZ = 200;//default number of Bins in histograms
653 const Float_t AliHBTFunction3D::fgkDefaultMinZ = -0.15;//Default min value of histograms
654 const Float_t AliHBTFunction3D::fgkDefaultMaxZ = 0.15;//Default max value of histograms
656 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleX = 30;//Default number of X bins used for scaling to tale
657 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleY = 30;//Default number of bins used for scaling to tale
658 const UInt_t AliHBTFunction3D::fgkDefaultNBinsToScaleZ = 30;//Default number of bins used for scaling to tale
660 AliHBTFunction3D::AliHBTFunction3D():
663 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
664 fNBinsToScaleY(fgkDefaultNBinsToScaleY),
665 fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
669 /******************************************************************/
671 AliHBTFunction3D::AliHBTFunction3D(const Char_t *name, const Char_t *title):
672 AliHBTFunction(name,title),
675 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
676 fNBinsToScaleY(fgkDefaultNBinsToScaleY),
677 fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
681 /******************************************************************/
683 AliHBTFunction3D::AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
684 Int_t nYbins, Double_t maxYval, Double_t minYval,
685 Int_t nZbins, Double_t maxZval, Double_t minZval):
688 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
689 fNBinsToScaleY(fgkDefaultNBinsToScaleY),
690 fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
693 BuildHistos( nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval);
695 /******************************************************************/
697 AliHBTFunction3D::AliHBTFunction3D(const Char_t *name, const Char_t *title,
698 Int_t nXbins, Double_t maxXval, Double_t minXval,
699 Int_t nYbins, Double_t maxYval, Double_t minYval,
700 Int_t nZbins, Double_t maxZval, Double_t minZval):
701 AliHBTFunction(name,title),
704 fNBinsToScaleX(fgkDefaultNBinsToScaleX),
705 fNBinsToScaleY(fgkDefaultNBinsToScaleY),
706 fNBinsToScaleZ(fgkDefaultNBinsToScaleZ)
709 BuildHistos( nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval);
711 /******************************************************************/
713 AliHBTFunction3D::AliHBTFunction3D(const AliHBTFunction3D& source):
714 AliHBTFunction(source)
716 // Copy constructor needed by the coding conventions byt not used
717 Fatal("AliHBTFunction3D(const AliHBTFunction3D&)","Cpy ctor not usable.");
719 /******************************************************************/
721 AliHBTFunction3D& AliHBTFunction3D::operator= (const AliHBTFunction3D & /*source*/)
723 // Assignment needed by the coding conventions byt not used
724 Fatal("Assignment operator","not implemented");
727 /******************************************************************/
730 AliHBTFunction3D::~AliHBTFunction3D()
735 /******************************************************************/
737 void AliHBTFunction3D::BuildHistos()
739 //Creates default histograms
740 BuildHistos(fgkDefaultNBinsX,fgkDefaultMaxX,fgkDefaultMinX,
741 fgkDefaultNBinsY,fgkDefaultMaxY,fgkDefaultMinY,
742 fgkDefaultNBinsZ,fgkDefaultMaxZ,fgkDefaultMinZ);
744 /******************************************************************/
746 void AliHBTFunction3D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
747 Int_t nybins, Float_t ymax, Float_t ymin,
748 Int_t nzbins, Float_t zmax, Float_t zmin)
750 //Builds numerator and denominator histograms (3d-case)
752 AliDebug(1,"Entered");
766 TString numstr = fName + " Numerator"; //title and name of the
767 //numerator histogram
768 TString denstr = fName + " Denominator";//title and name of the
769 //denominator histogram
771 fNumerator = new TH3F(numstr.Data(),numstr.Data(),
772 nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
774 fDenominator = new TH3F(denstr.Data(),denstr.Data(),
775 nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
778 fDenominator->Sumw2();
781 /******************************************************************/
783 Double_t AliHBTFunction3D::Scale()
785 // Calculates the factor that should be used to scale
786 // quatience of fNumerator and fDenominator to 1 at
788 AliDebug(1,"Entered");
791 AliError("No numerator");
796 AliError("No denominator");
800 if( (fNBinsToScaleX < 1) || (fNBinsToScaleY < 1) || (fNBinsToScaleZ < 1))
802 AliError("Number of bins for scaling is smaller thnan 1");
805 UInt_t nbinsX = fNumerator->GetNbinsX();
806 if (fNBinsToScaleX > nbinsX)
808 AliError("Number of X bins for scaling is bigger thnan number of bins in histograms");
812 UInt_t nbinsY = fNumerator->GetNbinsX();
813 if (fNBinsToScaleY > nbinsY)
815 AliError("Number of Y bins for scaling is bigger thnan number of bins in histograms");
819 UInt_t nbinsZ = fNumerator->GetNbinsZ();
820 if (fNBinsToScaleZ > nbinsZ)
822 AliError("Number of Z bins for scaling is bigger thnan number of bins in histograms");
826 AliDebug(1,"No errors detected");
828 Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
829 Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis Y
830 Int_t offsetZ = nbinsZ - fNBinsToScaleZ - 1; //bin that we start loop over bins in axis Z
832 Double_t densum = 0.0;
833 Double_t numsum = 0.0;
835 for (UInt_t k = offsetZ; k<nbinsZ; k++)
836 for (UInt_t j = offsetY; j<nbinsY; j++)
837 for (UInt_t i = offsetX; i<nbinsX; i++)
839 if ( fNumerator->GetBinContent(i,j,k) > 0.0 )
842 densum += fDenominator->GetBinContent(i,j,k);
843 numsum += fNumerator->GetBinContent(i,j,k);
847 AliDebug(1,Form("numsum=%f densum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d fNBinsToScaleZ=%d",
848 numsum,densum,fNBinsToScaleX,fNBinsToScaleY,fNBinsToScaleZ));
850 if (numsum == 0) return 0.0;
851 Double_t ret = densum/numsum;
853 AliDebug(1,Form("returning %f",ret));
856 /******************************************************************/
858 void AliHBTFunction3D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn,UInt_t zn)
860 //sets up the volume to be used for scaling to tail
866 /******************************************************************/
867 /******************************************************************/
868 /******************************************************************/
869 /******************************************************************/
870 /******************************************************************/
871 /******************************************************************/
872 /******************************************************************/
873 /******************************************************************/
874 /******************************************************************/
876 //____________________
877 ///////////////////////////////////////////////////////
879 // AliHBTOnePairFctn1D //
881 // Base Calss for 1-dimensinal Functions that need //
882 // one pair to fill function //
884 // Piotr.Skowronski@cern.ch //
885 // http://aliweb.cern.ch/people/skowron/analyzer //
887 ///////////////////////////////////////////////////////
889 ClassImp( AliHBTOnePairFctn1D )
890 /******************************************************************/
892 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
893 AliHBTFunction1D(nbins,maxXval,minXval)
897 /******************************************************************/
899 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title):
900 AliHBTFunction1D(name,title)
904 /******************************************************************/
906 AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
907 Int_t nbins, Float_t maxXval, Float_t minXval):
908 AliHBTFunction1D(name,title,nbins,maxXval,minXval)
912 /******************************************************************/
914 void AliHBTOnePairFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
916 //Fills the numerator using pair from the same event
917 pair = CheckPair(pair);
918 if(pair) fNumerator->Fill(GetValue(pair));
920 /******************************************************************/
921 void AliHBTOnePairFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
923 //Fills the denumerator using mixed pairs
924 pair = CheckPair(pair);
925 if(pair) fDenominator->Fill(GetValue(pair));
928 /******************************************************************/
929 /******************************************************************/
930 /******************************************************************/
932 //____________________
933 ///////////////////////////////////////////////////////
935 // AliHBTOnePairFctn2D //
937 // Base Calss for 2-dimensinal Functions that need //
938 // one pair to fill function //
940 // Piotr.Skowronski@cern.ch //
941 // http://aliweb.cern.ch/people/skowron/analyzer //
943 ///////////////////////////////////////////////////////
945 ClassImp( AliHBTOnePairFctn2D )
946 /******************************************************************/
948 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title):
949 AliHBTFunction2D(name,title)
953 /******************************************************************/
955 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
956 Int_t nYbins, Double_t maxYval, Double_t minYval):
957 AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
961 /******************************************************************/
963 AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
964 Int_t nXbins, Double_t maxXval, Double_t minXval,
965 Int_t nYbins, Double_t maxYval, Double_t minYval):
966 AliHBTFunction2D(name,title, nXbins, maxXval, minXval, nYbins, maxYval, minYval)
970 /******************************************************************/
972 void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
974 // Fills the numerator using pairs from the same event
975 pair = CheckPair(pair);
980 fNumerator->Fill(x,y);
983 /******************************************************************/
985 void AliHBTOnePairFctn2D::ProcessDiffEventParticles(AliHBTPair* pair)
987 // Fills the denumerator using mixed pairs
988 pair = CheckPair(pair);
993 fDenominator->Fill(x,y);
996 /******************************************************************/
997 /******************************************************************/
998 /******************************************************************/
999 /******************************************************************/
1000 //____________________
1001 ///////////////////////////////////////////////////////
1003 // AliHBTOnePairFctn3D //
1005 // Base Calss for 3-dimensinal Functions that need //
1006 // one pair to fill function //
1008 // Piotr.Skowronski@cern.ch //
1009 // http://aliweb.cern.ch/people/skowron/analyzer //
1011 ///////////////////////////////////////////////////////
1012 ClassImp( AliHBTOnePairFctn3D)
1014 /******************************************************************/
1016 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title):
1017 AliHBTFunction3D(name,title)
1021 /******************************************************************/
1023 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
1024 Int_t nYbins, Double_t maxYval, Double_t minYval,
1025 Int_t nZbins, Double_t maxZval, Double_t minZval):
1026 AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1030 /******************************************************************/
1032 AliHBTOnePairFctn3D::AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
1033 Int_t nXbins, Double_t maxXval, Double_t minXval,
1034 Int_t nYbins, Double_t maxYval, Double_t minYval,
1035 Int_t nZbins, Double_t maxZval, Double_t minZval):
1036 AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1040 /******************************************************************/
1042 void AliHBTOnePairFctn3D::ProcessSameEventParticles(AliHBTPair* pair)
1044 //Reacts on pair coming from same event (real pairs)
1045 //and fills numerator histogram
1046 pair = CheckPair(pair);
1050 GetValues(pair,x,y,z);
1051 fNumerator->Fill(x,y,z);
1054 /******************************************************************/
1056 void AliHBTOnePairFctn3D::ProcessDiffEventParticles(AliHBTPair* pair)
1058 //Reacts on pair coming from different events (mixed pairs)
1059 //and fills denominator histogram
1060 pair = CheckPair(pair);
1064 GetValues(pair,x,y,z);
1065 fDenominator->Fill(x,y,z);
1069 /******************************************************************/
1070 /******************************************************************/
1071 /******************************************************************/
1073 //____________________
1074 ///////////////////////////////////////////////////////
1076 // AliHBTTwoPairFctn1D //
1078 // Base Calss for 1-dimensinal Functions that need //
1079 // two pair (simulated and reconstructed) //
1080 // to fill function //
1082 // Piotr.Skowronski@cern.ch //
1083 // http://aliweb.cern.ch/people/skowron/analyzer //
1085 ///////////////////////////////////////////////////////
1086 ClassImp(AliHBTTwoPairFctn1D)
1087 /******************************************************************/
1089 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval):
1090 AliHBTFunction1D(nbins,maxXval,minXval)
1094 /******************************************************************/
1096 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title):
1097 AliHBTFunction1D(name,title)
1101 /******************************************************************/
1103 AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
1104 Int_t nbins, Float_t maxXval, Float_t minXval):
1105 AliHBTFunction1D(name,title,nbins,maxXval,minXval)
1109 /******************************************************************/
1111 void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1113 // Fills the numerator using pairs from the same event
1114 trackpair = CheckPair(trackpair);
1115 if( trackpair == 0x0) return;
1117 Double_t x = GetValue(trackpair,partpair);
1118 fNumerator->Fill(x);
1120 /******************************************************************/
1122 void AliHBTTwoPairFctn1D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1124 // Fills the denumerator usin mixed pairs
1125 trackpair = CheckPair(trackpair);
1126 if( trackpair == 0x0) return;
1128 Double_t x = GetValue(trackpair,partpair);
1129 fDenominator->Fill(x);
1131 /******************************************************************/
1132 /******************************************************************/
1133 /******************************************************************/
1135 //____________________
1136 ///////////////////////////////////////////////////////
1138 // AliHBTTwoPairFctn2D //
1140 // Base Calss for 2-dimensinal Functions that need //
1141 // two pair (simulated and reconstructed) //
1142 // to fill function //
1144 // Piotr.Skowronski@cern.ch //
1145 // http://aliweb.cern.ch/people/skowron/analyzer //
1147 ///////////////////////////////////////////////////////
1149 ClassImp(AliHBTTwoPairFctn2D)
1151 /******************************************************************/
1153 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title):
1154 AliHBTFunction2D(name,title)
1158 /******************************************************************/
1160 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
1161 Int_t nYbins, Double_t maxYval, Double_t minYval):
1162 AliHBTFunction2D(nXbins, maxXval, minXval, nYbins, maxYval, minYval)
1166 /******************************************************************/
1168 AliHBTTwoPairFctn2D::AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
1169 Int_t nXbins, Double_t maxXval, Double_t minXval,
1170 Int_t nYbins, Double_t maxYval, Double_t minYval):
1171 AliHBTFunction2D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval)
1175 /******************************************************************/
1177 void AliHBTTwoPairFctn2D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1179 //processes pair of particles coming from a same events (real pair)
1180 trackpair = CheckPair(trackpair);
1181 if( trackpair == 0x0) return;
1184 GetValues(trackpair,partpair,x,y);
1185 fNumerator->Fill(x,y);
1187 /******************************************************************/
1189 void AliHBTTwoPairFctn2D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1191 //processes pair of particles coming from a different events (mixed pair)
1192 trackpair = CheckPair(trackpair);
1193 if( trackpair == 0x0) return;
1196 GetValues(trackpair,partpair,x,y);
1197 fDenominator->Fill(x,y);
1200 /******************************************************************/
1201 /******************************************************************/
1202 /******************************************************************/
1204 //____________________
1205 ///////////////////////////////////////////////////////
1207 // AliHBTTwoPairFctn3D //
1209 // Base Calss for 3-dimensinal Functions that need //
1210 // two pair (simulated and reconstructed) //
1211 // to fill function //
1213 // Piotr.Skowronski@cern.ch //
1214 // http://aliweb.cern.ch/people/skowron/analyzer //
1216 ///////////////////////////////////////////////////////
1218 ClassImp(AliHBTTwoPairFctn3D)
1220 /******************************************************************/
1222 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title):
1223 AliHBTFunction3D(name,title)
1227 /******************************************************************/
1229 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
1230 Int_t nYbins, Double_t maxYval, Double_t minYval,
1231 Int_t nZbins, Double_t maxZval, Double_t minZval):
1232 AliHBTFunction3D(nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1236 /******************************************************************/
1238 AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
1239 Int_t nXbins, Double_t maxXval, Double_t minXval,
1240 Int_t nYbins, Double_t maxYval, Double_t minYval,
1241 Int_t nZbins, Double_t maxZval, Double_t minZval):
1242 AliHBTFunction3D(name,title,nXbins, maxXval, minXval, nYbins, maxYval, minYval, nZbins, maxZval, minZval)
1246 /******************************************************************/
1248 void AliHBTTwoPairFctn3D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1250 // Fills th numerator using pairs from the same event
1251 trackpair = CheckPair(trackpair);
1252 if( trackpair == 0x0) return;
1255 GetValues(trackpair,partpair,x,y,z);
1256 fNumerator->Fill(x,y,z);
1259 /******************************************************************/
1261 void AliHBTTwoPairFctn3D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
1263 // Fills the denumerator using mixed pairs
1264 trackpair = CheckPair(trackpair);
1265 if( trackpair == 0x0) return;
1268 GetValues(trackpair,partpair,x,y,z);
1269 fDenominator->Fill(x,y,z);
1272 /******************************************************************/
1273 /******************************************************************/
1274 /******************************************************************/