Logo ROOT  
Reference Guide
TH1.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Rene Brun 26/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include <cstdlib>
13#include <cstring>
14#include <cstdio>
15#include <cctype>
16#include <climits>
17#include <sstream>
18#include <cmath>
19#include <iostream>
20
21#include "TROOT.h"
22#include "TBuffer.h"
23#include "TEnv.h"
24#include "TClass.h"
25#include "TMath.h"
26#include "THashList.h"
27#include "TH1.h"
28#include "TH2.h"
29#include "TH3.h"
30#include "TF2.h"
31#include "TF3.h"
32#include "TPluginManager.h"
33#include "TVirtualPad.h"
34#include "TRandom.h"
35#include "TVirtualFitter.h"
36#include "THLimitsFinder.h"
37#include "TProfile.h"
38#include "TStyle.h"
39#include "TVectorF.h"
40#include "TVectorD.h"
41#include "TBrowser.h"
42#include "TError.h"
43#include "TVirtualHistPainter.h"
44#include "TVirtualFFT.h"
45#include "TVirtualPaveStats.h"
46
47#include "HFitInterface.h"
48#include "Fit/DataRange.h"
49#include "Fit/BinData.h"
50#include "Math/GoFTest.h"
53
54#include "TH1Merger.h"
55
56/** \addtogroup Histograms
57@{
58\class TH1C
59\brief 1-D histogram with a byte per channel (see TH1 documentation)
60\class TH1S
61\brief 1-D histogram with a short per channel (see TH1 documentation)
62\class TH1I
63\brief 1-D histogram with an int per channel (see TH1 documentation)}
64\class TH1F
65\brief 1-D histogram with a float per channel (see TH1 documentation)}
66\class TH1D
67\brief 1-D histogram with a double per channel (see TH1 documentation)}
68@}
69*/
70
71/** \class TH1
72 \ingroup Histograms
73TH1 is the base class of all histogram classes in %ROOT.
74
75It provides the common interface for operations such as binning, filling, drawing, which
76will be detailed below.
77
78-# [Creating histograms](\ref creating-histograms)
79 - [Labelling axes](\ref labelling-axis)
80-# [Binning](\ref binning)
81 - [Fix or variable bin size](\ref fix-var)
82 - [Convention for numbering bins](\ref convention)
83 - [Alphanumeric Bin Labels](\ref alpha)
84 - [Histograms with automatic bins](\ref auto-bin)
85 - [Rebinning](\ref rebinning)
86-# [Filling histograms](\ref filling-histograms)
87 - [Associated errors](\ref associated-errors)
88 - [Associated functions](\ref associated-functions)
89 - [Projections of histograms](\ref prof-hist)
90 - [Random Numbers and histograms](\ref random-numbers)
91 - [Making a copy of an histogram](\ref making-a-copy)
92 - [Normalizing histograms](\ref normalizing)
93-# [Drawing histograms](\ref drawing-histograms)
94 - [Setting Drawing histogram contour levels (2-D hists only)](\ref cont-level)
95 - [Setting histogram graphics attributes](\ref graph-att)
96 - [Customising how axes are drawn](\ref axis-drawing)
97-# [Saving/reading histograms to/from a ROOT file](\ref saving-histograms)
98-# [Operations on histograms](\ref operations-on-histograms)
99 - [Fitting histograms](\ref fitting-histograms)
100-# [Miscellaneous operations](\ref misc)
101
102ROOT supports the following histogram types:
103
104 - 1-D histograms:
105 - TH1C : histograms with one byte per channel. Maximum bin content = 127
106 - TH1S : histograms with one short per channel. Maximum bin content = 32767
107 - TH1I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
108 - TH1F : histograms with one float per channel. Maximum precision 7 digits
109 - TH1D : histograms with one double per channel. Maximum precision 14 digits
110 - 2-D histograms:
111 - TH2C : histograms with one byte per channel. Maximum bin content = 127
112 - TH2S : histograms with one short per channel. Maximum bin content = 32767
113 - TH2I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
114 - TH2F : histograms with one float per channel. Maximum precision 7 digits
115 - TH2D : histograms with one double per channel. Maximum precision 14 digits
116 - 3-D histograms:
117 - TH3C : histograms with one byte per channel. Maximum bin content = 127
118 - TH3S : histograms with one short per channel. Maximum bin content = 32767
119 - TH3I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
120 - TH3F : histograms with one float per channel. Maximum precision 7 digits
121 - TH3D : histograms with one double per channel. Maximum precision 14 digits
122 - Profile histograms: See classes TProfile, TProfile2D and TProfile3D.
123 Profile histograms are used to display the mean value of Y and its standard deviation
124 for each bin in X. Profile histograms are in many cases an elegant
125 replacement of two-dimensional histograms : the inter-relation of two
126 measured quantities X and Y can always be visualized by a two-dimensional
127 histogram or scatter-plot; If Y is an unknown (but single-valued)
128 approximate function of X, this function is displayed by a profile
129 histogram with much better precision than by a scatter-plot.
130
131<sup>
132\anchor intmax (*) INT_MAX = 2147483647 is the [maximum value for a variable of type int.](https://docs.microsoft.com/en-us/cpp/c-language/cpp-integer-limits)
133</sup>
134
135The inheritance hierarchy looks as follows:
136
137\image html classTH1__inherit__graph_org.svg width=100%
138
139\anchor creating-histograms
140## Creating histograms
141
142Histograms are created by invoking one of the constructors, e.g.
143~~~ {.cpp}
144 TH1F *h1 = new TH1F("h1", "h1 title", 100, 0, 4.4);
145 TH2F *h2 = new TH2F("h2", "h2 title", 40, 0, 4, 30, -3, 3);
146~~~
147Histograms may also be created by:
148
149 - calling the Clone() function, see below
150 - making a projection from a 2-D or 3-D histogram, see below
151 - reading an histogram from a file
152
153 When a histogram is created, a reference to it is automatically added
154 to the list of in-memory objects for the current file or directory.
155 Then the pointer to this histogram in the current directory can be found
156 by its name, doing:
157~~~ {.cpp}
158 TH1F *h1 = (TH1F*)gDirectory->FindObject(name);
159~~~
160
161 This default behaviour can be changed by:
162~~~ {.cpp}
163 h->SetDirectory(0); // for the current histogram h
164 TH1::AddDirectory(kFALSE); // sets a global switch disabling the referencing
165~~~
166 When the histogram is deleted, the reference to it is removed from
167 the list of objects in memory.
168 When a file is closed, all histograms in memory associated with this file
169 are automatically deleted.
170
171\anchor labelling-axis
172### Labelling axes
173
174 Axis titles can be specified in the title argument of the constructor.
175 They must be separated by ";":
176~~~ {.cpp}
177 TH1F* h=new TH1F("h", "Histogram title;X Axis;Y Axis", 100, 0, 1);
178~~~
179 The histogram title and the axis titles can be any TLatex string, and
180 are persisted if a histogram is written to a file.
181
182 Any title can be omitted:
183~~~ {.cpp}
184 TH1F* h=new TH1F("h", "Histogram title;;Y Axis", 100, 0, 1);
185 TH1F* h=new TH1F("h", ";;Y Axis", 100, 0, 1);
186~~~
187 The method SetTitle() has the same syntax:
188~~~ {.cpp}
189 h->SetTitle("Histogram title;Another X title Axis");
190~~~
191Alternatively, the title of each axis can be set directly:
192~~~ {.cpp}
193 h->GetXaxis()->SetTitle("X axis title");
194 h->GetYaxis()->SetTitle("Y axis title");
195~~~
196For bin labels see \ref binning.
197
198\anchor binning
199## Binning
200
201\anchor fix-var
202### Fix or variable bin size
203
204 All histogram types support either fix or variable bin sizes.
205 2-D histograms may have fix size bins along X and variable size bins
206 along Y or vice-versa. The functions to fill, manipulate, draw or access
207 histograms are identical in both cases.
208
209 Each histogram always contains 3 axis objects of type TAxis: fXaxis, fYaxis and fZaxis.
210 To access the axis parameters, use:
211~~~ {.cpp}
212 TAxis *xaxis = h->GetXaxis(); etc.
213 Double_t binCenter = xaxis->GetBinCenter(bin), etc.
214~~~
215 See class TAxis for a description of all the access functions.
216 The axis range is always stored internally in double precision.
217
218\anchor convention
219### Convention for numbering bins
220
221 For all histogram types: nbins, xlow, xup
222~~~ {.cpp}
223 bin = 0; underflow bin
224 bin = 1; first bin with low-edge xlow INCLUDED
225 bin = nbins; last bin with upper-edge xup EXCLUDED
226 bin = nbins+1; overflow bin
227~~~
228 In case of 2-D or 3-D histograms, a "global bin" number is defined.
229 For example, assuming a 3-D histogram with (binx, biny, binz), the function
230~~~ {.cpp}
231 Int_t gbin = h->GetBin(binx, biny, binz);
232~~~
233 returns a global/linearized gbin number. This global gbin is useful
234 to access the bin content/error information independently of the dimension.
235 Note that to access the information other than bin content and errors
236 one should use the TAxis object directly with e.g.:
237~~~ {.cpp}
238 Double_t xcenter = h3->GetZaxis()->GetBinCenter(27);
239~~~
240 returns the center along z of bin number 27 (not the global bin)
241 in the 3-D histogram h3.
242
243\anchor alpha
244### Alphanumeric Bin Labels
245
246 By default, an histogram axis is drawn with its numeric bin labels.
247 One can specify alphanumeric labels instead with:
248
249 - call TAxis::SetBinLabel(bin, label);
250 This can always be done before or after filling.
251 When the histogram is drawn, bin labels will be automatically drawn.
252 See examples labels1.C and labels2.C
253 - call to a Fill function with one of the arguments being a string, e.g.
254~~~ {.cpp}
255 hist1->Fill(somename, weight);
256 hist2->Fill(x, somename, weight);
257 hist2->Fill(somename, y, weight);
258 hist2->Fill(somenamex, somenamey, weight);
259~~~
260 See examples hlabels1.C and hlabels2.C
261 - via TTree::Draw. see for example cernstaff.C
262~~~ {.cpp}
263 tree.Draw("Nation::Division");
264~~~
265 where "Nation" and "Division" are two branches of a Tree.
266
267When using the options 2 or 3 above, the labels are automatically
268 added to the list (THashList) of labels for a given axis.
269 By default, an axis is drawn with the order of bins corresponding
270 to the filling sequence. It is possible to reorder the axis
272 - alphabetically
273 - by increasing or decreasing values
274
275 The reordering can be triggered via the TAxis context menu by selecting
276 the menu item "LabelsOption" or by calling directly
277 TH1::LabelsOption(option, axis) where
278
279 - axis may be "X", "Y" or "Z"
280 - option may be:
281 - "a" sort by alphabetic order
282 - ">" sort by decreasing values
283 - "<" sort by increasing values
284 - "h" draw labels horizontal
285 - "v" draw labels vertical
286 - "u" draw labels up (end of label right adjusted)
287 - "d" draw labels down (start of label left adjusted)
288
289 When using the option 2 above, new labels are added by doubling the current
290 number of bins in case one label does not exist yet.
291 When the Filling is terminated, it is possible to trim the number
292 of bins to match the number of active labels by calling
293~~~ {.cpp}
294 TH1::LabelsDeflate(axis) with axis = "X", "Y" or "Z"
295~~~
296 This operation is automatic when using TTree::Draw.
297 Once bin labels have been created, they become persistent if the histogram
298 is written to a file or when generating the C++ code via SavePrimitive.
299
300\anchor auto-bin
301### Histograms with automatic bins
302
303 When an histogram is created with an axis lower limit greater or equal
304 to its upper limit, the SetBuffer is automatically called with an
305 argument fBufferSize equal to fgBufferSize (default value=1000).
306 fgBufferSize may be reset via the static function TH1::SetDefaultBufferSize.
307 The axis limits will be automatically computed when the buffer will
308 be full or when the function BufferEmpty is called.
309
310\anchor rebinning
311### Rebinning
312
313 At any time, an histogram can be rebinned via TH1::Rebin. This function
314 returns a new histogram with the rebinned contents.
315 If bin errors were stored, they are recomputed during the rebinning.
316
317
318\anchor filling-histograms
319## Filling histograms
320
321 An histogram is typically filled with statements like:
322~~~ {.cpp}
323 h1->Fill(x);
324 h1->Fill(x, w); //fill with weight
325 h2->Fill(x, y)
326 h2->Fill(x, y, w)
327 h3->Fill(x, y, z)
328 h3->Fill(x, y, z, w)
329~~~
330 or via one of the Fill functions accepting names described above.
331 The Fill functions compute the bin number corresponding to the given
332 x, y or z argument and increment this bin by the given weight.
333 The Fill functions return the bin number for 1-D histograms or global
334 bin number for 2-D and 3-D histograms.
335 If TH1::Sumw2 has been called before filling, the sum of squares of
336 weights is also stored.
337 One can also increment directly a bin number via TH1::AddBinContent
338 or replace the existing content via TH1::SetBinContent.
339 To access the bin content of a given bin, do:
340~~~ {.cpp}
341 Double_t binContent = h->GetBinContent(bin);
342~~~
343
344 By default, the bin number is computed using the current axis ranges.
345 If the automatic binning option has been set via
346~~~ {.cpp}
347 h->SetCanExtend(TH1::kAllAxes);
348~~~
349 then, the Fill Function will automatically extend the axis range to
350 accomodate the new value specified in the Fill argument. The method
351 used is to double the bin size until the new value fits in the range,
352 merging bins two by two. This automatic binning options is extensively
353 used by the TTree::Draw function when histogramming Tree variables
354 with an unknown range.
355 This automatic binning option is supported for 1-D, 2-D and 3-D histograms.
356
357 During filling, some statistics parameters are incremented to compute
358 the mean value and Root Mean Square with the maximum precision.
359
360 In case of histograms of type TH1C, TH1S, TH2C, TH2S, TH3C, TH3S
361 a check is made that the bin contents do not exceed the maximum positive
362 capacity (127 or 32767). Histograms of all types may have positive
363 or/and negative bin contents.
364
365\anchor associated-errors
366### Associated errors
367 By default, for each bin, the sum of weights is computed at fill time.
368 One can also call TH1::Sumw2 to force the storage and computation
369 of the sum of the square of weights per bin.
370 If Sumw2 has been called, the error per bin is computed as the
371 sqrt(sum of squares of weights), otherwise the error is set equal
372 to the sqrt(bin content).
373 To return the error for a given bin number, do:
374~~~ {.cpp}
375 Double_t error = h->GetBinError(bin);
376~~~
377
378\anchor associated-functions
379### Associated functions
380 One or more object (typically a TF1*) can be added to the list
381 of functions (fFunctions) associated to each histogram.
382 When TH1::Fit is invoked, the fitted function is added to this list.
383 Given an histogram h, one can retrieve an associated function
384 with:
385~~~ {.cpp}
386 TF1 *myfunc = h->GetFunction("myfunc");
387~~~
388
389
390\anchor operations-on-histograms
391## Operations on histograms
392
393 Many types of operations are supported on histograms or between histograms
394
395 - Addition of an histogram to the current histogram.
396 - Additions of two histograms with coefficients and storage into the current
397 histogram.
398 - Multiplications and Divisions are supported in the same way as additions.
399 - The Add, Divide and Multiply functions also exist to add, divide or multiply
400 an histogram by a function.
401
402 If an histogram has associated error bars (TH1::Sumw2 has been called),
403 the resulting error bars are also computed assuming independent histograms.
404 In case of divisions, Binomial errors are also supported.
405 One can mark a histogram to be an "average" histogram by setting its bit kIsAverage via
406 myhist.SetBit(TH1::kIsAverage);
407 When adding (see TH1::Add) average histograms, the histograms are averaged and not summed.
408
409\anchor fitting-histograms
410### Fitting histograms
411
412 Histograms (1-D, 2-D, 3-D and Profiles) can be fitted with a user
413 specified function via TH1::Fit. When an histogram is fitted, the
414 resulting function with its parameters is added to the list of functions
415 of this histogram. If the histogram is made persistent, the list of
416 associated functions is also persistent. Given a pointer (see above)
417 to an associated function myfunc, one can retrieve the function/fit
418 parameters with calls such as:
419~~~ {.cpp}
420 Double_t chi2 = myfunc->GetChisquare();
421 Double_t par0 = myfunc->GetParameter(0); value of 1st parameter
422 Double_t err0 = myfunc->GetParError(0); error on first parameter
423~~~
424
425\anchor prof-hist
426### Projections of histograms
427
428 One can:
429
430 - make a 1-D projection of a 2-D histogram or Profile
431 see functions TH2::ProjectionX,Y, TH2::ProfileX,Y, TProfile::ProjectionX
432 - make a 1-D, 2-D or profile out of a 3-D histogram
433 see functions TH3::ProjectionZ, TH3::Project3D.
434
435 One can fit these projections via:
436~~~ {.cpp}
437 TH2::FitSlicesX,Y, TH3::FitSlicesZ.
438~~~
439
440\anchor random-numbers
441### Random Numbers and histograms
442
443 TH1::FillRandom can be used to randomly fill an histogram using
444 the contents of an existing TF1 function or another
445 TH1 histogram (for all dimensions).
446 For example the following two statements create and fill an histogram
447 10000 times with a default gaussian distribution of mean 0 and sigma 1:
448~~~ {.cpp}
449 TH1F h1("h1", "histo from a gaussian", 100, -3, 3);
450 h1.FillRandom("gaus", 10000);
451~~~
452 TH1::GetRandom can be used to return a random number distributed
453 according the contents of an histogram.
454
455\anchor making-a-copy
456### Making a copy of an histogram
457 Like for any other ROOT object derived from TObject, one can use
458 the Clone() function. This makes an identical copy of the original
459 histogram including all associated errors and functions, e.g.:
460~~~ {.cpp}
461 TH1F *hnew = (TH1F*)h->Clone("hnew");
462~~~
463
464\anchor normalizing
465### Normalizing histograms
466
467 One can scale an histogram such that the bins integral is equal to
468 the normalization parameter via TH1::Scale(Double_t norm), where norm
469 is the desired normalization divided by the integral of the histogram.
470
471
472\anchor drawing-histograms
473## Drawing histograms
474
475 Histograms are drawn via the THistPainter class. Each histogram has
476 a pointer to its own painter (to be usable in a multithreaded program).
477 Many drawing options are supported.
478 See THistPainter::Paint() for more details.
479
480 The same histogram can be drawn with different options in different pads.
481 When an histogram drawn in a pad is deleted, the histogram is
482 automatically removed from the pad or pads where it was drawn.
483 If an histogram is drawn in a pad, then filled again, the new status
484 of the histogram will be automatically shown in the pad next time
485 the pad is updated. One does not need to redraw the histogram.
486 To draw the current version of an histogram in a pad, one can use
487~~~ {.cpp}
488 h->DrawCopy();
489~~~
490 This makes a clone (see Clone below) of the histogram. Once the clone
491 is drawn, the original histogram may be modified or deleted without
492 affecting the aspect of the clone.
493
494 One can use TH1::SetMaximum() and TH1::SetMinimum() to force a particular
495 value for the maximum or the minimum scale on the plot. (For 1-D
496 histograms this means the y-axis, while for 2-D histograms these
497 functions affect the z-axis).
498
499 TH1::UseCurrentStyle() can be used to change all histogram graphics
500 attributes to correspond to the current selected style.
501 This function must be called for each histogram.
502 In case one reads and draws many histograms from a file, one can force
503 the histograms to inherit automatically the current graphics style
504 by calling before gROOT->ForceStyle().
505
506\anchor cont-level
507### Setting Drawing histogram contour levels (2-D hists only)
508
509 By default contours are automatically generated at equidistant
510 intervals. A default value of 20 levels is used. This can be modified
511 via TH1::SetContour() or TH1::SetContourLevel().
512 the contours level info is used by the drawing options "cont", "surf",
513 and "lego".
514
515\anchor graph-att
516### Setting histogram graphics attributes
517
518 The histogram classes inherit from the attribute classes:
519 TAttLine, TAttFill, and TAttMarker.
520 See the member functions of these classes for the list of options.
521
522\anchor axis-drawing
523### Customising how axes are drawn
524
525 Use the functions of TAxis, such as
526~~~ {.cpp}
527 histogram.GetXaxis()->SetTicks("+");
528 histogram.GetYaxis()->SetRangeUser(1., 5.);
529~~~
530
531\anchor saving-histograms
532## Saving/reading histograms to/from a ROOT file
533
534 The following statements create a ROOT file and store an histogram
535 on the file. Because TH1 derives from TNamed, the key identifier on
536 the file is the histogram name:
537~~~ {.cpp}
538 TFile f("histos.root", "new");
539 TH1F h1("hgaus", "histo from a gaussian", 100, -3, 3);
540 h1.FillRandom("gaus", 10000);
541 h1->Write();
542~~~
543 To read this histogram in another Root session, do:
544~~~ {.cpp}
545 TFile f("histos.root");
546 TH1F *h = (TH1F*)f.Get("hgaus");
547~~~
548 One can save all histograms in memory to the file by:
549~~~ {.cpp}
550 file->Write();
551~~~
552
553
554\anchor misc
555## Miscellaneous operations
556
557~~~ {.cpp}
558 TH1::KolmogorovTest(): statistical test of compatibility in shape
559 between two histograms
560 TH1::Smooth() smooths the bin contents of a 1-d histogram
561 TH1::Integral() returns the integral of bin contents in a given bin range
562 TH1::GetMean(int axis) returns the mean value along axis
563 TH1::GetStdDev(int axis) returns the sigma distribution along axis
564 TH1::GetEntries() returns the number of entries
565 TH1::Reset() resets the bin contents and errors of an histogram
566~~~
567 IMPORTANT NOTE: The returned values for GetMean and GetStdDev depend on how the
568 histogram statistics are calculated. By default, if no range has been set, the
569 returned values are the (unbinned) ones calculated at fill time. If a range has been
570 set, however, the values are calculated using the bins in range; THIS IS TRUE EVEN
571 IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset the range.
572 To ensure that the returned values are always those of the binned data stored in the
573 histogram, call TH1::ResetStats. See TH1::GetStats.
574*/
575
576TF1 *gF1=0; //left for back compatibility (use TVirtualFitter::GetUserFunc instead)
577
582
583extern void H1InitGaus();
584extern void H1InitExpo();
585extern void H1InitPolynom();
586extern void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a);
587extern void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail);
588extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b);
589
590// Internal exceptions for the CheckConsistency method
591class DifferentDimension: public std::exception {};
592class DifferentNumberOfBins: public std::exception {};
593class DifferentAxisLimits: public std::exception {};
594class DifferentBinLimits: public std::exception {};
595class DifferentLabels: public std::exception {};
596
598
599////////////////////////////////////////////////////////////////////////////////
600/// Histogram default constructor.
601
603{
604 fDirectory = 0;
605 fFunctions = new TList;
606 fNcells = 0;
607 fIntegral = 0;
608 fPainter = 0;
609 fEntries = 0;
610 fNormFactor = 0;
612 fMaximum = -1111;
613 fMinimum = -1111;
614 fBufferSize = 0;
615 fBuffer = 0;
617 fStatOverflows = EStatOverflows::kNeutral;
618 fXaxis.SetName("xaxis");
619 fYaxis.SetName("yaxis");
620 fZaxis.SetName("zaxis");
621 fXaxis.SetParent(this);
622 fYaxis.SetParent(this);
623 fZaxis.SetParent(this);
625}
626
627////////////////////////////////////////////////////////////////////////////////
628/// Histogram default destructor.
629
631{
632 if (!TestBit(kNotDeleted)) {
633 return;
634 }
635 delete[] fIntegral;
636 fIntegral = 0;
637 delete[] fBuffer;
638 fBuffer = 0;
639 if (fFunctions) {
641
643 TObject* obj = 0;
644 //special logic to support the case where the same object is
645 //added multiple times in fFunctions.
646 //This case happens when the same object is added with different
647 //drawing modes
648 //In the loop below we must be careful with objects (eg TCutG) that may
649 // have been added to the list of functions of several histograms
650 //and may have been already deleted.
651 while ((obj = fFunctions->First())) {
652 while(fFunctions->Remove(obj)) { }
653 if (!obj->TestBit(kNotDeleted)) {
654 break;
655 }
656 delete obj;
657 obj = 0;
658 }
659 delete fFunctions;
660 fFunctions = 0;
661 }
662 if (fDirectory) {
663 fDirectory->Remove(this);
664 fDirectory = 0;
665 }
666 delete fPainter;
667 fPainter = 0;
668}
669
670////////////////////////////////////////////////////////////////////////////////
671/// Constructor for fix bin size histograms.
672/// Creates the main histogram structure.
673///
674/// \param[in] name name of histogram (avoid blanks)
675/// \param[in] title histogram title.
676/// If title is of the form `stringt;stringx;stringy;stringz`,
677/// the histogram title is set to `stringt`,
678/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
679/// \param[in] nbins number of bins
680/// \param[in] xlow low edge of first bin
681/// \param[in] xup upper edge of last bin (not included in last bin)
682
683
684TH1::TH1(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
685 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
686{
687 Build();
688 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
689 fXaxis.Set(nbins,xlow,xup);
690 fNcells = fXaxis.GetNbins()+2;
691}
692
693////////////////////////////////////////////////////////////////////////////////
694/// Constructor for variable bin size histograms using an input array of type float.
695/// Creates the main histogram structure.
696///
697/// \param[in] name name of histogram (avoid blanks)
698/// \param[in] title histogram title.
699/// If title is of the form `stringt;stringx;stringy;stringz`
700/// the histogram title is set to `stringt`,
701/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
702/// \param[in] nbins number of bins
703/// \param[in] xbins array of low-edges for each bin.
704/// This is an array of type float and size nbins+1
705
706TH1::TH1(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
707 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
708{
709 Build();
710 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
711 if (xbins) fXaxis.Set(nbins,xbins);
712 else fXaxis.Set(nbins,0,1);
713 fNcells = fXaxis.GetNbins()+2;
714}
715
716////////////////////////////////////////////////////////////////////////////////
717/// Constructor for variable bin size histograms using an input array of type double.
718///
719/// \param[in] name name of histogram (avoid blanks)
720/// \param[in] title histogram title.
721/// If title is of the form `stringt;stringx;stringy;stringz`
722/// the histogram title is set to `stringt`,
723/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
724/// \param[in] nbins number of bins
725/// \param[in] xbins array of low-edges for each bin.
726/// This is an array of type double and size nbins+1
727
728TH1::TH1(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
729 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
730{
731 Build();
732 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
733 if (xbins) fXaxis.Set(nbins,xbins);
734 else fXaxis.Set(nbins,0,1);
735 fNcells = fXaxis.GetNbins()+2;
736}
737
738////////////////////////////////////////////////////////////////////////////////
739/// Private copy constructor.
740/// One should use the copy constructor of the derived classes (e.g. TH1D, TH1F ...).
741/// The list of functions is not copied. (Use Clone() if needed)
742
744{
745 ((TH1&)h).Copy(*this);
746}
747
748////////////////////////////////////////////////////////////////////////////////
749/// Static function: cannot be inlined on Windows/NT.
750
752{
753 return fgAddDirectory;
754}
755
756////////////////////////////////////////////////////////////////////////////////
757/// Browse the Histogram object.
758
760{
761 Draw(b ? b->GetDrawOption() : "");
762 gPad->Update();
763}
764
765////////////////////////////////////////////////////////////////////////////////
766/// Creates histogram basic data structure.
767
769{
770 fDirectory = 0;
771 fPainter = 0;
772 fIntegral = 0;
773 fEntries = 0;
774 fNormFactor = 0;
776 fMaximum = -1111;
777 fMinimum = -1111;
778 fBufferSize = 0;
779 fBuffer = 0;
781 fStatOverflows = EStatOverflows::kNeutral;
782 fXaxis.SetName("xaxis");
783 fYaxis.SetName("yaxis");
784 fZaxis.SetName("zaxis");
785 fYaxis.Set(1,0.,1.);
786 fZaxis.Set(1,0.,1.);
787 fXaxis.SetParent(this);
788 fYaxis.SetParent(this);
789 fZaxis.SetParent(this);
790
792
793 fFunctions = new TList;
794
796
799 if (fDirectory) {
801 fDirectory->Append(this,kTRUE);
802 }
803 }
804}
805
806////////////////////////////////////////////////////////////////////////////////
807/// Performs the operation: `this = this + c1*f1`
808/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
809///
810/// By default, the function is computed at the centre of the bin.
811/// if option "I" is specified (1-d histogram only), the integral of the
812/// function in each bin is used instead of the value of the function at
813/// the centre of the bin.
814///
815/// Only bins inside the function range are recomputed.
816///
817/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
818/// you should call Sumw2 before making this operation.
819/// This is particularly important if you fit the histogram after TH1::Add
820///
821/// The function return kFALSE if the Add operation failed
822
824{
825 if (!f1) {
826 Error("Add","Attempt to add a non-existing function");
827 return kFALSE;
828 }
829
830 TString opt = option;
831 opt.ToLower();
832 Bool_t integral = kFALSE;
833 if (opt.Contains("i") && fDimension == 1) integral = kTRUE;
834
835 Int_t ncellsx = GetNbinsX() + 2; // cells = normal bins + underflow bin + overflow bin
836 Int_t ncellsy = GetNbinsY() + 2;
837 Int_t ncellsz = GetNbinsZ() + 2;
838 if (fDimension < 2) ncellsy = 1;
839 if (fDimension < 3) ncellsz = 1;
840
841 // delete buffer if it is there since it will become invalid
842 if (fBuffer) BufferEmpty(1);
843
844 // - Add statistics
845 Double_t s1[10];
846 for (Int_t i = 0; i < 10; ++i) s1[i] = 0;
847 PutStats(s1);
848 SetMinimum();
849 SetMaximum();
850
851 // - Loop on bins (including underflows/overflows)
852 Int_t bin, binx, biny, binz;
853 Double_t cu=0;
854 Double_t xx[3];
855 Double_t *params = 0;
856 f1->InitArgs(xx,params);
857 for (binz = 0; binz < ncellsz; ++binz) {
858 xx[2] = fZaxis.GetBinCenter(binz);
859 for (biny = 0; biny < ncellsy; ++biny) {
860 xx[1] = fYaxis.GetBinCenter(biny);
861 for (binx = 0; binx < ncellsx; ++binx) {
862 xx[0] = fXaxis.GetBinCenter(binx);
863 if (!f1->IsInside(xx)) continue;
865 bin = binx + ncellsx * (biny + ncellsy * binz);
866 if (integral) {
867 cu = c1*f1->Integral(fXaxis.GetBinLowEdge(binx), fXaxis.GetBinUpEdge(binx), 0.) / fXaxis.GetBinWidth(binx);
868 } else {
869 cu = c1*f1->EvalPar(xx);
870 }
871 if (TF1::RejectedPoint()) continue;
872 AddBinContent(bin,cu);
873 }
874 }
875 }
876
877 return kTRUE;
878}
879
880////////////////////////////////////////////////////////////////////////////////
881/// Performs the operation: `this = this + c1*h1`
882/// If errors are defined (see TH1::Sumw2), errors are also recalculated.
883///
884/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
885/// if not already set.
886///
887/// Note also that adding histogram with labels is not supported, histogram will be
888/// added merging them by bin number independently of the labels.
889/// For adding histogram with labels one should use TH1::Merge
890///
891/// SPECIAL CASE (Average/Efficiency histograms)
892/// For histograms representing averages or efficiencies, one should compute the average
893/// of the two histograms and not the sum. One can mark a histogram to be an average
894/// histogram by setting its bit kIsAverage with
895/// myhist.SetBit(TH1::kIsAverage);
896/// Note that the two histograms must have their kIsAverage bit set
897///
898/// IMPORTANT NOTE1: If you intend to use the errors of this histogram later
899/// you should call Sumw2 before making this operation.
900/// This is particularly important if you fit the histogram after TH1::Add
901///
902/// IMPORTANT NOTE2: if h1 has a normalisation factor, the normalisation factor
903/// is used , ie this = this + c1*factor*h1
904/// Use the other TH1::Add function if you do not want this feature
905///
906/// IMPORTANT NOTE3: You should be careful about the statistics of the
907/// returned histogram, whose statistics may be binned or unbinned,
908/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
909/// and whether TH1::ResetStats has been called on either this or h1.
910/// See TH1::GetStats.
911///
912/// The function return kFALSE if the Add operation failed
913
915{
916 if (!h1) {
917 Error("Add","Attempt to add a non-existing histogram");
918 return kFALSE;
919 }
920
921 // delete buffer if it is there since it will become invalid
922 if (fBuffer) BufferEmpty(1);
923
924 bool useMerge = (c1 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
925 try {
926 CheckConsistency(this,h1);
927 useMerge = kFALSE;
928 } catch(DifferentNumberOfBins&) {
929 if (useMerge)
930 Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
931 else {
932 Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 = %d",GetNbinsX(), h1->GetNbinsX());
933 return kFALSE;
934 }
935 } catch(DifferentAxisLimits&) {
936 if (useMerge)
937 Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
938 else
939 Warning("Add","Attempt to add histograms with different axis limits");
940 } catch(DifferentBinLimits&) {
941 if (useMerge)
942 Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
943 else
944 Warning("Add","Attempt to add histograms with different bin limits");
945 } catch(DifferentLabels&) {
946 // in case of different labels -
947 if (useMerge)
948 Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
949 else
950 Info("Warning","Attempt to add histograms with different labels");
951 }
952
953 if (useMerge) {
954 TList l;
955 l.Add(const_cast<TH1*>(h1));
956 auto iret = Merge(&l);
957 return (iret >= 0);
958 }
959
960 // Create Sumw2 if h1 has Sumw2 set
961 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
962
963 // - Add statistics
964 Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() );
965
966 // statistics can be preserved only in case of positive coefficients
967 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
968 Bool_t resetStats = (c1 < 0);
969 Double_t s1[kNstat] = {0};
970 Double_t s2[kNstat] = {0};
971 if (!resetStats) {
972 // need to initialize to zero s1 and s2 since
973 // GetStats fills only used elements depending on dimension and type
974 GetStats(s1);
975 h1->GetStats(s2);
976 }
977
978 SetMinimum();
979 SetMaximum();
980
981 // - Loop on bins (including underflows/overflows)
982 Double_t factor = 1;
983 if (h1->GetNormFactor() != 0) factor = h1->GetNormFactor()/h1->GetSumOfWeights();;
984 Double_t c1sq = c1 * c1;
985 Double_t factsq = factor * factor;
986
987 for (Int_t bin = 0; bin < fNcells; ++bin) {
988 //special case where histograms have the kIsAverage bit set
989 if (this->TestBit(kIsAverage) && h1->TestBit(kIsAverage)) {
990 Double_t y1 = h1->RetrieveBinContent(bin);
991 Double_t y2 = this->RetrieveBinContent(bin);
993 Double_t e2sq = this->GetBinErrorSqUnchecked(bin);
994 Double_t w1 = 1., w2 = 1.;
995
996 // consider all special cases when bin errors are zero
997 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
998 if (e1sq) w1 = 1. / e1sq;
999 else if (h1->fSumw2.fN) {
1000 w1 = 1.E200; // use an arbitrary huge value
1001 if (y1 == 0) {
1002 // use an estimated error from the global histogram scale
1003 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
1004 w1 = 1./(sf*sf);
1005 }
1006 }
1007 if (e2sq) w2 = 1. / e2sq;
1008 else if (fSumw2.fN) {
1009 w2 = 1.E200; // use an arbitrary huge value
1010 if (y2 == 0) {
1011 // use an estimated error from the global histogram scale
1012 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
1013 w2 = 1./(sf*sf);
1014 }
1015 }
1016
1017 double y = (w1*y1 + w2*y2)/(w1 + w2);
1018 UpdateBinContent(bin, y);
1019 if (fSumw2.fN) {
1020 double err2 = 1./(w1 + w2);
1021 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1022 fSumw2.fArray[bin] = err2;
1023 }
1024 } else { // normal case of addition between histograms
1025 AddBinContent(bin, c1 * factor * h1->RetrieveBinContent(bin));
1026 if (fSumw2.fN) fSumw2.fArray[bin] += c1sq * factsq * h1->GetBinErrorSqUnchecked(bin);
1027 }
1028 }
1029
1030 // update statistics (do here to avoid changes by SetBinContent)
1031 if (resetStats) {
1032 // statistics need to be reset in case coefficient are negative
1033 ResetStats();
1034 }
1035 else {
1036 for (Int_t i=0;i<kNstat;i++) {
1037 if (i == 1) s1[i] += c1*c1*s2[i];
1038 else s1[i] += c1*s2[i];
1039 }
1040 PutStats(s1);
1041 SetEntries(entries);
1042 }
1043 return kTRUE;
1044}
1045
1046////////////////////////////////////////////////////////////////////////////////
1047/// Replace contents of this histogram by the addition of h1 and h2.
1048///
1049/// `this = c1*h1 + c2*h2`
1050/// if errors are defined (see TH1::Sumw2), errors are also recalculated
1051///
1052/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
1053/// if not already set.
1054///
1055/// Note also that adding histogram with labels is not supported, histogram will be
1056/// added merging them by bin number independently of the labels.
1057/// For adding histogram ith labels one should use TH1::Merge
1058///
1059/// SPECIAL CASE (Average/Efficiency histograms)
1060/// For histograms representing averages or efficiencies, one should compute the average
1061/// of the two histograms and not the sum. One can mark a histogram to be an average
1062/// histogram by setting its bit kIsAverage with
1063/// myhist.SetBit(TH1::kIsAverage);
1064/// Note that the two histograms must have their kIsAverage bit set
1065///
1066/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
1067/// you should call Sumw2 before making this operation.
1068/// This is particularly important if you fit the histogram after TH1::Add
1069///
1070/// IMPORTANT NOTE2: You should be careful about the statistics of the
1071/// returned histogram, whose statistics may be binned or unbinned,
1072/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
1073/// and whether TH1::ResetStats has been called on either this or h1.
1074/// See TH1::GetStats.
1075///
1076/// ANOTHER SPECIAL CASE : h1 = h2 and c2 < 0
1077/// do a scaling this = c1 * h1 / (bin Volume)
1078///
1079/// The function returns kFALSE if the Add operation failed
1080
1082{
1083
1084 if (!h1 || !h2) {
1085 Error("Add","Attempt to add a non-existing histogram");
1086 return kFALSE;
1087 }
1088
1089 // delete buffer if it is there since it will become invalid
1090 if (fBuffer) BufferEmpty(1);
1091
1092 Bool_t normWidth = kFALSE;
1093 if (h1 == h2 && c2 < 0) {c2 = 0; normWidth = kTRUE;}
1094
1095 if (h1 != h2) {
1096 bool useMerge = (c1 == 1. && c2 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
1097
1098 try {
1099 CheckConsistency(h1,h2);
1100 CheckConsistency(this,h1);
1101 useMerge = kFALSE;
1102 } catch(DifferentNumberOfBins&) {
1103 if (useMerge)
1104 Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
1105 else {
1106 Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 = %d",GetNbinsX(), h1->GetNbinsX());
1107 return kFALSE;
1108 }
1109 } catch(DifferentAxisLimits&) {
1110 if (useMerge)
1111 Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
1112 else
1113 Warning("Add","Attempt to add histograms with different axis limits");
1114 } catch(DifferentBinLimits&) {
1115 if (useMerge)
1116 Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
1117 else
1118 Warning("Add","Attempt to add histograms with different bin limits");
1119 } catch(DifferentLabels&) {
1120 // in case of different labels -
1121 if (useMerge)
1122 Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
1123 else
1124 Info("Warning","Attempt to add histograms with different labels");
1125 }
1126
1127 if (useMerge) {
1128 TList l;
1129 // why TList takes non-const pointers ????
1130 l.Add(const_cast<TH1*>(h1));
1131 l.Add(const_cast<TH1*>(h2));
1132 Reset("ICE");
1133 auto iret = Merge(&l);
1134 return (iret >= 0);
1135 }
1136 }
1137
1138 // Create Sumw2 if h1 or h2 have Sumw2 set
1139 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();
1140
1141 // - Add statistics
1142 Double_t nEntries = TMath::Abs( c1*h1->GetEntries() + c2*h2->GetEntries() );
1143
1144 // TODO remove
1145 // statistics can be preserved only in case of positive coefficients
1146 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
1147 // also in case of scaling with the width we cannot preserve the statistics
1148 Double_t s1[kNstat] = {0};
1149 Double_t s2[kNstat] = {0};
1150 Double_t s3[kNstat];
1151
1152
1153 Bool_t resetStats = (c1*c2 < 0) || normWidth;
1154 if (!resetStats) {
1155 // need to initialize to zero s1 and s2 since
1156 // GetStats fills only used elements depending on dimension and type
1157 h1->GetStats(s1);
1158 h2->GetStats(s2);
1159 for (Int_t i=0;i<kNstat;i++) {
1160 if (i == 1) s3[i] = c1*c1*s1[i] + c2*c2*s2[i];
1161 //else s3[i] = TMath::Abs(c1)*s1[i] + TMath::Abs(c2)*s2[i];
1162 else s3[i] = c1*s1[i] + c2*s2[i];
1163 }
1164 }
1165
1166 SetMinimum();
1167 SetMaximum();
1168
1169 if (normWidth) { // DEPRECATED CASE: belongs to fitting / drawing modules
1170
1171 Int_t nbinsx = GetNbinsX() + 2; // normal bins + underflow, overflow
1172 Int_t nbinsy = GetNbinsY() + 2;
1173 Int_t nbinsz = GetNbinsZ() + 2;
1174
1175 if (fDimension < 2) nbinsy = 1;
1176 if (fDimension < 3) nbinsz = 1;
1177
1178 Int_t bin, binx, biny, binz;
1179 for (binz = 0; binz < nbinsz; ++binz) {
1180 Double_t wz = h1->GetZaxis()->GetBinWidth(binz);
1181 for (biny = 0; biny < nbinsy; ++biny) {
1182 Double_t wy = h1->GetYaxis()->GetBinWidth(biny);
1183 for (binx = 0; binx < nbinsx; ++binx) {
1184 Double_t wx = h1->GetXaxis()->GetBinWidth(binx);
1185 bin = GetBin(binx, biny, binz);
1186 Double_t w = wx*wy*wz;
1187 UpdateBinContent(bin, c1 * h1->RetrieveBinContent(bin) / w);
1188 if (fSumw2.fN) {
1189 Double_t e1 = h1->GetBinError(bin)/w;
1190 fSumw2.fArray[bin] = c1*c1*e1*e1;
1191 }
1192 }
1193 }
1194 }
1195 } else if (h1->TestBit(kIsAverage) && h2->TestBit(kIsAverage)) {
1196 for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
1197 // special case where histograms have the kIsAverage bit set
1199 Double_t y2 = h2->RetrieveBinContent(i);
1201 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
1202 Double_t w1 = 1., w2 = 1.;
1203
1204 // consider all special cases when bin errors are zero
1205 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
1206 if (e1sq) w1 = 1./ e1sq;
1207 else if (h1->fSumw2.fN) {
1208 w1 = 1.E200; // use an arbitrary huge value
1209 if (y1 == 0 ) { // use an estimated error from the global histogram scale
1210 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
1211 w1 = 1./(sf*sf);
1212 }
1213 }
1214 if (e2sq) w2 = 1./ e2sq;
1215 else if (h2->fSumw2.fN) {
1216 w2 = 1.E200; // use an arbitrary huge value
1217 if (y2 == 0) { // use an estimated error from the global histogram scale
1218 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
1219 w2 = 1./(sf*sf);
1220 }
1221 }
1222
1223 double y = (w1*y1 + w2*y2)/(w1 + w2);
1224 UpdateBinContent(i, y);
1225 if (fSumw2.fN) {
1226 double err2 = 1./(w1 + w2);
1227 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1228 fSumw2.fArray[i] = err2;
1229 }
1230 }
1231 } else { // case of simple histogram addition
1232 Double_t c1sq = c1 * c1;
1233 Double_t c2sq = c2 * c2;
1234 for (Int_t i = 0; i < fNcells; ++i) { // Loop on cells (bins including underflows/overflows)
1236 if (fSumw2.fN) {
1237 fSumw2.fArray[i] = c1sq * h1->GetBinErrorSqUnchecked(i) + c2sq * h2->GetBinErrorSqUnchecked(i);
1238 }
1239 }
1240 }
1241
1242 if (resetStats) {
1243 // statistics need to be reset in case coefficient are negative
1244 ResetStats();
1245 }
1246 else {
1247 // update statistics (do here to avoid changes by SetBinContent) FIXME remove???
1248 PutStats(s3);
1249 SetEntries(nEntries);
1250 }
1251
1252 return kTRUE;
1253}
1254
1255////////////////////////////////////////////////////////////////////////////////
1256/// Increment bin content by 1.
1257
1259{
1260 AbstractMethod("AddBinContent");
1261}
1262
1263////////////////////////////////////////////////////////////////////////////////
1264/// Increment bin content by a weight w.
1265
1267{
1268 AbstractMethod("AddBinContent");
1269}
1270
1271////////////////////////////////////////////////////////////////////////////////
1272/// Sets the flag controlling the automatic add of histograms in memory
1273///
1274/// By default (fAddDirectory = kTRUE), histograms are automatically added
1275/// to the list of objects in memory.
1276/// Note that one histogram can be removed from its support directory
1277/// by calling h->SetDirectory(0) or h->SetDirectory(dir) to add it
1278/// to the list of objects in the directory dir.
1279///
1280/// NOTE that this is a static function. To call it, use;
1281/// TH1::AddDirectory
1282
1284{
1285 fgAddDirectory = add;
1286}
1287
1288////////////////////////////////////////////////////////////////////////////////
1289/// Auxiliary function to get the power of 2 next (larger) or previous (smaller)
1290/// a given x
1291///
1292/// next = kTRUE : next larger
1293/// next = kFALSE : previous smaller
1294///
1295/// Used by the autobin power of 2 algorithm
1296
1298{
1299 Int_t nn;
1300 Double_t f2 = std::frexp(x, &nn);
1301 return ((next && x > 0.) || (!next && x <= 0.)) ? std::ldexp(std::copysign(1., f2), nn)
1302 : std::ldexp(std::copysign(1., f2), --nn);
1303}
1304
1305////////////////////////////////////////////////////////////////////////////////
1306/// Auxiliary function to get the next power of 2 integer value larger then n
1307///
1308/// Used by the autobin power of 2 algorithm
1309
1311{
1312 Int_t nn;
1313 Double_t f2 = std::frexp(n, &nn);
1314 if (TMath::Abs(f2 - .5) > 0.001)
1315 return (Int_t)std::ldexp(1., nn);
1316 return n;
1317}
1318
1319////////////////////////////////////////////////////////////////////////////////
1320/// Buffer-based estimate of the histogram range using the power of 2 algorithm.
1321///
1322/// Used by the autobin power of 2 algorithm.
1323///
1324/// Works on arguments (min and max from fBuffer) and internal inputs: fXmin,
1325/// fXmax, NBinsX (from fXaxis), ...
1326/// Result save internally in fXaxis.
1327///
1328/// Overloaded by TH2 and TH3.
1329///
1330/// Return -1 if internal inputs are inconsistent, 0 otherwise.
1331
1333{
1334 // We need meaningful raw limits
1335 if (xmi >= xma)
1336 return -1;
1337
1339 Double_t xhmi = fXaxis.GetXmin();
1340 Double_t xhma = fXaxis.GetXmax();
1341
1342 // Now adjust
1343 if (TMath::Abs(xhma) > TMath::Abs(xhmi)) {
1344 // Start from the upper limit
1345 xhma = TH1::AutoP2GetPower2(xhma);
1346 xhmi = xhma - TH1::AutoP2GetPower2(xhma - xhmi);
1347 } else {
1348 // Start from the lower limit
1349 xhmi = TH1::AutoP2GetPower2(xhmi, kFALSE);
1350 xhma = xhmi + TH1::AutoP2GetPower2(xhma - xhmi);
1351 }
1352
1353 // Round the bins to the next power of 2; take into account the possible inflation
1354 // of the range
1355 Double_t rr = (xhma - xhmi) / (xma - xmi);
1356 Int_t nb = TH1::AutoP2GetBins((Int_t)(rr * GetNbinsX()));
1357
1358 // Adjust using the same bin width and offsets
1359 Double_t bw = (xhma - xhmi) / nb;
1360 // Bins to left free on each side
1361 Double_t autoside = gEnv->GetValue("Hist.Binning.Auto.Side", 0.05);
1362 Int_t nbside = (Int_t)(nb * autoside);
1363
1364 // Side up
1365 Int_t nbup = (xhma - xma) / bw;
1366 if (nbup % 2 != 0)
1367 nbup++; // Must be even
1368 if (nbup != nbside) {
1369 // Accounts also for both case: larger or smaller
1370 xhma -= bw * (nbup - nbside);
1371 nb -= (nbup - nbside);
1372 }
1373
1374 // Side low
1375 Int_t nblw = (xmi - xhmi) / bw;
1376 if (nblw % 2 != 0)
1377 nblw++; // Must be even
1378 if (nblw != nbside) {
1379 // Accounts also for both case: larger or smaller
1380 xhmi += bw * (nblw - nbside);
1381 nb -= (nblw - nbside);
1382 }
1383
1384 // Set everything and project
1385 SetBins(nb, xhmi, xhma);
1386
1387 // Done
1388 return 0;
1389}
1390
1391/// Fill histogram with all entries in the buffer.
1392///
1393/// - action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
1394/// - action = 0 histogram is reset and filled from the buffer. When the histogram is filled from the
1395/// buffer the value fBuffer[0] is set to a negative number (= - number of entries)
1396/// When calling with action == 0 the histogram is NOT refilled when fBuffer[0] is < 0
1397/// While when calling with action = -1 the histogram is reset and ALWAYS refilled independently if
1398/// the histogram was filled before. This is needed when drawing the histogram
1399/// - action = 1 histogram is filled and buffer is deleted
1400/// The buffer is automatically deleted when filling the histogram and the entries is
1401/// larger than the buffer size
1402
1404{
1405 // do we need to compute the bin size?
1406 if (!fBuffer) return 0;
1407 Int_t nbentries = (Int_t)fBuffer[0];
1408
1409 // nbentries correspond to the number of entries of histogram
1410
1411 if (nbentries == 0) {
1412 // if action is 1 we delete the buffer
1413 // this will avoid infinite recursion
1414 if (action > 0) {
1415 delete [] fBuffer;
1416 fBuffer = 0;
1417 fBufferSize = 0;
1418 }
1419 return 0;
1420 }
1421 if (nbentries < 0 && action == 0) return 0; // case histogram has been already filled from the buffer
1422
1423 Double_t *buffer = fBuffer;
1424 if (nbentries < 0) {
1425 nbentries = -nbentries;
1426 // a reset might call BufferEmpty() giving an infinite recursion
1427 // Protect it by setting fBuffer = 0
1428 fBuffer=0;
1429 //do not reset the list of functions
1430 Reset("ICES");
1431 fBuffer = buffer;
1432 }
1433 if (CanExtendAllAxes() || (fXaxis.GetXmax() <= fXaxis.GetXmin())) {
1434 //find min, max of entries in buffer
1435 Double_t xmin = fBuffer[2];
1436 Double_t xmax = xmin;
1437 for (Int_t i=1;i<nbentries;i++) {
1438 Double_t x = fBuffer[2*i+2];
1439 if (x < xmin) xmin = x;
1440 if (x > xmax) xmax = x;
1441 }
1442 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
1443 Int_t rc = -1;
1445 if ((rc = AutoP2FindLimits(xmin, xmax)) < 0)
1446 Warning("BufferEmpty",
1447 "inconsistency found by power-of-2 autobin algorithm: fallback to standard method");
1448 }
1449 if (rc < 0)
1451 } else {
1452 fBuffer = 0;
1453 Int_t keep = fBufferSize; fBufferSize = 0;
1455 if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax, &fXaxis);
1456 fBuffer = buffer;
1457 fBufferSize = keep;
1458 }
1459 }
1460
1461 // call DoFillN which will not put entries in the buffer as FillN does
1462 // set fBuffer to zero to avoid re-emptying the buffer from functions called
1463 // by DoFillN (e.g Sumw2)
1464 buffer = fBuffer; fBuffer = 0;
1465 DoFillN(nbentries,&buffer[2],&buffer[1],2);
1466 fBuffer = buffer;
1467
1468 // if action == 1 - delete the buffer
1469 if (action > 0) {
1470 delete [] fBuffer;
1471 fBuffer = 0;
1472 fBufferSize = 0;
1473 } else {
1474 // if number of entries is consistent with buffer - set it negative to avoid
1475 // refilling the histogram every time BufferEmpty(0) is called
1476 // In case it is not consistent, by setting fBuffer[0]=0 is like resetting the buffer
1477 // (it will not be used anymore the next time BufferEmpty is called)
1478 if (nbentries == (Int_t)fEntries)
1479 fBuffer[0] = -nbentries;
1480 else
1481 fBuffer[0] = 0;
1482 }
1483 return nbentries;
1484}
1485
1486////////////////////////////////////////////////////////////////////////////////
1487/// accumulate arguments in buffer. When buffer is full, empty the buffer
1488///
1489/// - `fBuffer[0]` = number of entries in buffer
1490/// - `fBuffer[1]` = w of first entry
1491/// - `fBuffer[2]` = x of first entry
1492
1494{
1495 if (!fBuffer) return -2;
1496 Int_t nbentries = (Int_t)fBuffer[0];
1497
1498
1499 if (nbentries < 0) {
1500 // reset nbentries to a positive value so next time BufferEmpty() is called
1501 // the histogram will be refilled
1502 nbentries = -nbentries;
1503 fBuffer[0] = nbentries;
1504 if (fEntries > 0) {
1505 // set fBuffer to zero to avoid calling BufferEmpty in Reset
1506 Double_t *buffer = fBuffer; fBuffer=0;
1507 Reset("ICES"); // do not reset list of functions
1508 fBuffer = buffer;
1509 }
1510 }
1511 if (2*nbentries+2 >= fBufferSize) {
1512 BufferEmpty(1);
1513 if (!fBuffer)
1514 // to avoid infinite recursion Fill->BufferFill->Fill
1515 return Fill(x,w);
1516 // this cannot happen
1517 R__ASSERT(0);
1518 }
1519 fBuffer[2*nbentries+1] = w;
1520 fBuffer[2*nbentries+2] = x;
1521 fBuffer[0] += 1;
1522 return -2;
1523}
1524
1525////////////////////////////////////////////////////////////////////////////////
1526/// Check bin limits.
1527
1528bool TH1::CheckBinLimits(const TAxis* a1, const TAxis * a2)
1529{
1530 const TArrayD * h1Array = a1->GetXbins();
1531 const TArrayD * h2Array = a2->GetXbins();
1532 Int_t fN = h1Array->fN;
1533 if ( fN != 0 ) {
1534 if ( h2Array->fN != fN ) {
1535 throw DifferentBinLimits();
1536 return false;
1537 }
1538 else {
1539 for ( int i = 0; i < fN; ++i ) {
1540 // for i==fN (nbin+1) a->GetBinWidth() returns last bin width
1541 // we do not need to exclude that case
1542 double binWidth = a1->GetBinWidth(i);
1543 if ( ! TMath::AreEqualAbs( h1Array->GetAt(i), h2Array->GetAt(i), binWidth*1E-10 ) ) {
1544 throw DifferentBinLimits();
1545 return false;
1546 }
1547 }
1548 }
1549 }
1550
1551 return true;
1552}
1553
1554////////////////////////////////////////////////////////////////////////////////
1555/// Check that axis have same labels.
1556
1557bool TH1::CheckBinLabels(const TAxis* a1, const TAxis * a2)
1558{
1559 THashList *l1 = a1->GetLabels();
1560 THashList *l2 = a2->GetLabels();
1561
1562 if (!l1 && !l2 )
1563 return true;
1564 if (!l1 || !l2 ) {
1565 throw DifferentLabels();
1566 return false;
1567 }
1568 // check now labels sizes are the same
1569 if (l1->GetSize() != l2->GetSize() ) {
1570 throw DifferentLabels();
1571 return false;
1572 }
1573 for (int i = 1; i <= a1->GetNbins(); ++i) {
1574 TString label1 = a1->GetBinLabel(i);
1575 TString label2 = a2->GetBinLabel(i);
1576 if (label1 != label2) {
1577 throw DifferentLabels();
1578 return false;
1579 }
1580 }
1581
1582 return true;
1583}
1584
1585////////////////////////////////////////////////////////////////////////////////
1586/// Check that the axis limits of the histograms are the same.
1587/// If a first and last bin is passed the axis is compared between the given range
1588
1589bool TH1::CheckAxisLimits(const TAxis *a1, const TAxis *a2 )
1590{
1591 double firstBin = a1->GetBinWidth(1);
1592 double lastBin = a1->GetBinWidth( a1->GetNbins() );
1593 if ( ! TMath::AreEqualAbs(a1->GetXmin(), a2->GetXmin(), firstBin* 1.E-10) ||
1594 ! TMath::AreEqualAbs(a1->GetXmax(), a2->GetXmax(), lastBin*1.E-10) ) {
1595 throw DifferentAxisLimits();
1596 return false;
1597 }
1598 return true;
1599}
1600
1601////////////////////////////////////////////////////////////////////////////////
1602/// Check that the axis are the same
1603
1604bool TH1::CheckEqualAxes(const TAxis *a1, const TAxis *a2 )
1605{
1606 if (a1->GetNbins() != a2->GetNbins() ) {
1607 //throw DifferentNumberOfBins();
1608 ::Info("CheckEqualAxes","Axes have different number of bins : nbin1 = %d nbin2 = %d",a1->GetNbins(),a2->GetNbins() );
1609 return false;
1610 }
1611 try {
1612 CheckAxisLimits(a1,a2);
1613 } catch (DifferentAxisLimits&) {
1614 ::Info("CheckEqualAxes","Axes have different limits");
1615 return false;
1616 }
1617 try {
1618 CheckBinLimits(a1,a2);
1619 } catch (DifferentBinLimits&) {
1620 ::Info("CheckEqualAxes","Axes have different bin limits");
1621 return false;
1622 }
1623
1624 // check labels
1625 try {
1626 CheckBinLabels(a1,a2);
1627 } catch (DifferentLabels&) {
1628 ::Info("CheckEqualAxes","Axes have different labels");
1629 return false;
1630 }
1631
1632 return true;
1633}
1634
1635////////////////////////////////////////////////////////////////////////////////
1636/// Check that two sub axis are the same.
1637/// The limits are defined by first bin and last bin
1638/// N.B. no check is done in this case for variable bins
1639
1640bool TH1::CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis * a2, Int_t firstBin2, Int_t lastBin2 )
1641{
1642 // By default is assumed that no bins are given for the second axis
1643 Int_t nbins1 = lastBin1-firstBin1 + 1;
1644 Double_t xmin1 = a1->GetBinLowEdge(firstBin1);
1645 Double_t xmax1 = a1->GetBinUpEdge(lastBin1);
1646
1647 Int_t nbins2 = a2->GetNbins();
1648 Double_t xmin2 = a2->GetXmin();
1649 Double_t xmax2 = a2->GetXmax();
1650
1651 if (firstBin2 < lastBin2) {
1652 // in this case assume no bins are given for the second axis
1653 nbins2 = lastBin1-firstBin1 + 1;
1654 xmin2 = a1->GetBinLowEdge(firstBin1);
1655 xmax2 = a1->GetBinUpEdge(lastBin1);
1656 }
1657
1658 if (nbins1 != nbins2 ) {
1659 ::Info("CheckConsistentSubAxes","Axes have different number of bins");
1660 return false;
1661 }
1662
1663 Double_t firstBin = a1->GetBinWidth(firstBin1);
1664 Double_t lastBin = a1->GetBinWidth(lastBin1);
1665 if ( ! TMath::AreEqualAbs(xmin1,xmin2,1.E-10 * firstBin) ||
1666 ! TMath::AreEqualAbs(xmax1,xmax2,1.E-10 * lastBin) ) {
1667 ::Info("CheckConsistentSubAxes","Axes have different limits");
1668 return false;
1669 }
1670
1671 return true;
1672}
1673
1674////////////////////////////////////////////////////////////////////////////////
1675/// Check histogram compatibility.
1676
1677bool TH1::CheckConsistency(const TH1* h1, const TH1* h2)
1678{
1679 if (h1 == h2) return true;
1680
1681 if (h1->GetDimension() != h2->GetDimension() ) {
1682 throw DifferentDimension();
1683 return false;
1684 }
1685 Int_t dim = h1->GetDimension();
1686
1687 // returns kTRUE if number of bins and bin limits are identical
1688 Int_t nbinsx = h1->GetNbinsX();
1689 Int_t nbinsy = h1->GetNbinsY();
1690 Int_t nbinsz = h1->GetNbinsZ();
1691
1692 // Check whether the histograms have the same number of bins.
1693 if (nbinsx != h2->GetNbinsX() ||
1694 (dim > 1 && nbinsy != h2->GetNbinsY()) ||
1695 (dim > 2 && nbinsz != h2->GetNbinsZ()) ) {
1696 throw DifferentNumberOfBins();
1697 return false;
1698 }
1699
1700 bool ret = true;
1701
1702 // check axis limits
1703 ret &= CheckAxisLimits(h1->GetXaxis(), h2->GetXaxis());
1704 if (dim > 1) ret &= CheckAxisLimits(h1->GetYaxis(), h2->GetYaxis());
1705 if (dim > 2) ret &= CheckAxisLimits(h1->GetZaxis(), h2->GetZaxis());
1706
1707 // check bin limits
1708 ret &= CheckBinLimits(h1->GetXaxis(), h2->GetXaxis());
1709 if (dim > 1) ret &= CheckBinLimits(h1->GetYaxis(), h2->GetYaxis());
1710 if (dim > 2) ret &= CheckBinLimits(h1->GetZaxis(), h2->GetZaxis());
1711
1712 // check labels if histograms are both not empty
1713 if ( !h1->IsEmpty() && !h2->IsEmpty() ) {
1714 ret &= CheckBinLabels(h1->GetXaxis(), h2->GetXaxis());
1715 if (dim > 1) ret &= CheckBinLabels(h1->GetYaxis(), h2->GetYaxis());
1716 if (dim > 2) ret &= CheckBinLabels(h1->GetZaxis(), h2->GetZaxis());
1717 }
1718
1719 return ret;
1720}
1721
1722////////////////////////////////////////////////////////////////////////////////
1723/// \f$ \chi^{2} \f$ test for comparing weighted and unweighted histograms
1724///
1725/// Function: Returns p-value. Other return values are specified by the 3rd parameter
1726///
1727/// \param[in] h2 the second histogram
1728/// \param[in] option
1729/// - "UU" = experiment experiment comparison (unweighted-unweighted)
1730/// - "UW" = experiment MC comparison (unweighted-weighted). Note that
1731/// the first histogram should be unweighted
1732/// - "WW" = MC MC comparison (weighted-weighted)
1733/// - "NORM" = to be used when one or both of the histograms is scaled
1734/// but the histogram originally was unweighted
1735/// - by default underflows and overflows are not included:
1736/// * "OF" = overflows included
1737/// * "UF" = underflows included
1738/// - "P" = print chi2, ndf, p_value, igood
1739/// - "CHI2" = returns chi2 instead of p-value
1740/// - "CHI2/NDF" = returns \f$ \chi^{2} \f$/ndf
1741/// \param[in] res not empty - computes normalized residuals and returns them in this array
1742///
1743/// The current implementation is based on the papers \f$ \chi^{2} \f$ test for comparison
1744/// of weighted and unweighted histograms" in Proceedings of PHYSTAT05 and
1745/// "Comparison weighted and unweighted histograms", arXiv:physics/0605123
1746/// by N.Gagunashvili. This function has been implemented by Daniel Haertl in August 2006.
1747///
1748/// #### Introduction:
1749///
1750/// A frequently used technique in data analysis is the comparison of
1751/// histograms. First suggested by Pearson [1] the \f$ \chi^{2} \f$ test of
1752/// homogeneity is used widely for comparing usual (unweighted) histograms.
1753/// This paper describes the implementation modified \f$ \chi^{2} \f$ tests
1754/// for comparison of weighted and unweighted histograms and two weighted
1755/// histograms [2] as well as usual Pearson's \f$ \chi^{2} \f$ test for
1756/// comparison two usual (unweighted) histograms.
1757///
1758/// #### Overview:
1759///
1760/// Comparison of two histograms expect hypotheses that two histograms
1761/// represent identical distributions. To make a decision p-value should
1762/// be calculated. The hypotheses of identity is rejected if the p-value is
1763/// lower then some significance level. Traditionally significance levels
1764/// 0.1, 0.05 and 0.01 are used. The comparison procedure should include an
1765/// analysis of the residuals which is often helpful in identifying the
1766/// bins of histograms responsible for a significant overall \f$ \chi^{2} \f$ value.
1767/// Residuals are the difference between bin contents and expected bin
1768/// contents. Most convenient for analysis are the normalized residuals. If
1769/// hypotheses of identity are valid then normalized residuals are
1770/// approximately independent and identically distributed random variables
1771/// having N(0,1) distribution. Analysis of residuals expect test of above
1772/// mentioned properties of residuals. Notice that indirectly the analysis
1773/// of residuals increase the power of \f$ \chi^{2} \f$ test.
1774///
1775/// #### Methods of comparison:
1776///
1777/// \f$ \chi^{2} \f$ test for comparison two (unweighted) histograms:
1778/// Let us consider two histograms with the same binning and the number
1779/// of bins equal to r. Let us denote the number of events in the ith bin
1780/// in the first histogram as ni and as mi in the second one. The total
1781/// number of events in the first histogram is equal to:
1782/// \f[
1783/// N = \sum_{i=1}^{r} n_{i}
1784/// \f]
1785/// and
1786/// \f[
1787/// M = \sum_{i=1}^{r} m_{i}
1788/// \f]
1789/// in the second histogram. The hypothesis of identity (homogeneity) [3]
1790/// is that the two histograms represent random values with identical
1791/// distributions. It is equivalent that there exist r constants p1,...,pr,
1792/// such that
1793/// \f[
1794///\sum_{i=1}^{r} p_{i}=1
1795/// \f]
1796/// and the probability of belonging to the ith bin for some measured value
1797/// in both experiments is equal to pi. The number of events in the ith
1798/// bin is a random variable with a distribution approximated by a Poisson
1799/// probability distribution
1800/// \f[
1801///\frac{e^{-Np_{i}}(Np_{i})^{n_{i}}}{n_{i}!}
1802/// \f]
1803///for the first histogram and with distribution
1804/// \f[
1805///\frac{e^{-Mp_{i}}(Mp_{i})^{m_{i}}}{m_{i}!}
1806/// \f]
1807/// for the second histogram. If the hypothesis of homogeneity is valid,
1808/// then the maximum likelihood estimator of pi, i=1,...,r, is
1809/// \f[
1810///\hat{p}_{i}= \frac{n_{i}+m_{i}}{N+M}
1811/// \f]
1812/// and then
1813/// \f[
1814/// X^{2} = \sum_{i=1}^{r}\frac{(n_{i}-N\hat{p}_{i})^{2}}{N\hat{p}_{i}} + \sum_{i=1}^{r}\frac{(m_{i}-M\hat{p}_{i})^{2}}{M\hat{p}_{i}} =\frac{1}{MN} \sum_{i=1}^{r}\frac{(Mn_{i}-Nm_{i})^{2}}{n_{i}+m_{i}}
1815/// \f]
1816/// has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [3].
1817/// The comparison procedure can include an analysis of the residuals which
1818/// is often helpful in identifying the bins of histograms responsible for
1819/// a significant overall \f$ \chi^{2} \f$ value. Most convenient for
1820/// analysis are the adjusted (normalized) residuals [4]
1821/// \f[
1822/// r_{i} = \frac{n_{i}-N\hat{p}_{i}}{\sqrt{N\hat{p}_{i}}\sqrt{(1-N/(N+M))(1-(n_{i}+m_{i})/(N+M))}}
1823/// \f]
1824/// If hypotheses of homogeneity are valid then residuals ri are
1825/// approximately independent and identically distributed random variables
1826/// having N(0,1) distribution. The application of the \f$ \chi^{2} \f$ test has
1827/// restrictions related to the value of the expected frequencies Npi,
1828/// Mpi, i=1,...,r. A conservative rule formulated in [5] is that all the
1829/// expectations must be 1 or greater for both histograms. In practical
1830/// cases when expected frequencies are not known the estimated expected
1831/// frequencies \f$ M\hat{p}_{i}, N\hat{p}_{i}, i=1,...,r \f$ can be used.
1832///
1833/// #### Unweighted and weighted histograms comparison:
1834///
1835/// A simple modification of the ideas described above can be used for the
1836/// comparison of the usual (unweighted) and weighted histograms. Let us
1837/// denote the number of events in the ith bin in the unweighted
1838/// histogram as ni and the common weight of events in the ith bin of the
1839/// weighted histogram as wi. The total number of events in the
1840/// unweighted histogram is equal to
1841///\f[
1842/// N = \sum_{i=1}^{r} n_{i}
1843///\f]
1844/// and the total weight of events in the weighted histogram is equal to
1845///\f[
1846/// W = \sum_{i=1}^{r} w_{i}
1847///\f]
1848/// Let us formulate the hypothesis of identity of an unweighted histogram
1849/// to a weighted histogram so that there exist r constants p1,...,pr, such
1850/// that
1851///\f[
1852/// \sum_{i=1}^{r} p_{i} = 1
1853///\f]
1854/// for the unweighted histogram. The weight wi is a random variable with a
1855/// distribution approximated by the normal probability distribution
1856/// \f$ N(Wp_{i},\sigma_{i}^{2}) \f$ where \f$ \sigma_{i}^{2} \f$ is the variance of the weight wi.
1857/// If we replace the variance \f$ \sigma_{i}^{2} \f$
1858/// with estimate \f$ s_{i}^{2} \f$ (sum of squares of weights of
1859/// events in the ith bin) and the hypothesis of identity is valid, then the
1860/// maximum likelihood estimator of pi,i=1,...,r, is
1861///\f[
1862/// \hat{p}_{i} = \frac{Ww_{i}-Ns_{i}^{2}+\sqrt{(Ww_{i}-Ns_{i}^{2})^{2}+4W^{2}s_{i}^{2}n_{i}}}{2W^{2}}
1863///\f]
1864/// We may then use the test statistic
1865///\f[
1866/// X^{2} = \sum_{i=1}^{r} \frac{(n_{i}-N\hat{p}_{i})^{2}}{N\hat{p}_{i}} + \sum_{i=1}^{r} \frac{(w_{i}-W\hat{p}_{i})^{2}}{s_{i}^{2}}
1867///\f]
1868/// and it has approximately a \f$ \sigma^{2}_{(r-1)} \f$ distribution [2]. This test, as well
1869/// as the original one [3], has a restriction on the expected frequencies. The
1870/// expected frequencies recommended for the weighted histogram is more than 25.
1871/// The value of the minimal expected frequency can be decreased down to 10 for
1872/// the case when the weights of the events are close to constant. In the case
1873/// of a weighted histogram if the number of events is unknown, then we can
1874/// apply this recommendation for the equivalent number of events as
1875///\f[
1876/// n_{i}^{equiv} = \frac{ w_{i}^{2} }{ s_{i}^{2} }
1877///\f]
1878/// The minimal expected frequency for an unweighted histogram must be 1. Notice
1879/// that any usual (unweighted) histogram can be considered as a weighted
1880/// histogram with events that have constant weights equal to 1.
1881/// The variance \f$ z_{i}^{2} \f$ of the difference between the weight wi
1882/// and the estimated expectation value of the weight is approximately equal to:
1883///\f[
1884/// z_{i}^{2} = Var(w_{i}-W\hat{p}_{i}) = N\hat{p}_{i}(1-N\hat{p}_{i})\left(\frac{Ws_{i}^{2}}{\sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}\right)^{2}+\frac{s_{i}^{2}}{4}\left(1+\frac{Ns_{i}^{2}-w_{i}W}{\sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}\right)^{2}
1885///\f]
1886/// The residuals
1887///\f[
1888/// r_{i} = \frac{w_{i}-W\hat{p}_{i}}{z_{i}}
1889///\f]
1890/// have approximately a normal distribution with mean equal to 0 and standard
1891/// deviation equal to 1.
1892///
1893/// #### Two weighted histograms comparison:
1894///
1895/// Let us denote the common weight of events of the ith bin in the first
1896/// histogram as w1i and as w2i in the second one. The total weight of events
1897/// in the first histogram is equal to
1898///\f[
1899/// W_{1} = \sum_{i=1}^{r} w_{1i}
1900///\f]
1901/// and
1902///\f[
1903/// W_{2} = \sum_{i=1}^{r} w_{2i}
1904///\f]
1905/// in the second histogram. Let us formulate the hypothesis of identity of
1906/// weighted histograms so that there exist r constants p1,...,pr, such that
1907///\f[
1908/// \sum_{i=1}^{r} p_{i} = 1
1909///\f]
1910/// and also expectation value of weight w1i equal to W1pi and expectation value
1911/// of weight w2i equal to W2pi. Weights in both the histograms are random
1912/// variables with distributions which can be approximated by a normal
1913/// probability distribution \f$ N(W_{1}p_{i},\sigma_{1i}^{2}) \f$ for the first histogram
1914/// and by a distribution \f$ N(W_{2}p_{i},\sigma_{2i}^{2}) \f$ for the second.
1915/// Here \f$ \sigma_{1i}^{2} \f$ and \f$ \sigma_{2i}^{2} \f$ are the variances
1916/// of w1i and w2i with estimators \f$ s_{1i}^{2} \f$ and \f$ s_{2i}^{2} \f$ respectively.
1917/// If the hypothesis of identity is valid, then the maximum likelihood and
1918/// Least Square Method estimator of pi,i=1,...,r, is
1919///\f[
1920/// \hat{p}_{i} = \frac{w_{1i}W_{1}/s_{1i}^{2}+w_{2i}W_{2} /s_{2i}^{2}}{W_{1}^{2}/s_{1i}^{2}+W_{2}^{2}/s_{2i}^{2}}
1921///\f]
1922/// We may then use the test statistic
1923///\f[
1924/// X^{2} = \sum_{i=1}^{r} \frac{(w_{1i}-W_{1}\hat{p}_{i})^{2}}{s_{1i}^{2}} + \sum_{i=1}^{r} \frac{(w_{2i}-W_{2}\hat{p}_{i})^{2}}{s_{2i}^{2}} = \sum_{i=1}^{r} \frac{(W_{1}w_{2i}-W_{2}w_{1i})^{2}}{W_{1}^{2}s_{2i}^{2}+W_{2}^{2}s_{1i}^{2}}
1925///\f]
1926/// and it has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [2].
1927/// The normalized or studentised residuals [6]
1928///\f[
1929/// r_{i} = \frac{w_{1i}-W_{1}\hat{p}_{i}}{s_{1i}\sqrt{1 - \frac{1}{(1+W_{2}^{2}s_{1i}^{2}/W_{1}^{2}s_{2i}^{2})}}}
1930///\f]
1931/// have approximately a normal distribution with mean equal to 0 and standard
1932/// deviation 1. A recommended minimal expected frequency is equal to 10 for
1933/// the proposed test.
1934///
1935/// #### Numerical examples:
1936///
1937/// The method described herein is now illustrated with an example.
1938/// We take a distribution
1939///\f[
1940/// \phi(x) = \frac{2}{(x-10)^{2}+1} + \frac{1}{(x-14)^{2}+1} (1)
1941///\f]
1942/// defined on the interval [4,16]. Events distributed according to the formula
1943/// (1) are simulated to create the unweighted histogram. Uniformly distributed
1944/// events are simulated for the weighted histogram with weights calculated by
1945/// formula (1). Each histogram has the same number of bins: 20. Fig.1 shows
1946/// the result of comparison of the unweighted histogram with 200 events
1947/// (minimal expected frequency equal to one) and the weighted histogram with
1948/// 500 events (minimal expected frequency equal to 25)
1949/// Begin_Macro
1950/// ../../../tutorials/math/chi2test.C
1951/// End_Macro
1952/// Fig 1. An example of comparison of the unweighted histogram with 200 events
1953/// and the weighted histogram with 500 events:
1954/// 1. unweighted histogram;
1955/// 2. weighted histogram;
1956/// 3. normalized residuals plot;
1957/// 4. normal Q-Q plot of residuals.
1958///
1959/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1960/// 21.09 with p-value equal to 0.33, therefore the hypothesis of identity of
1961/// the two histograms can be accepted for 0.05 significant level. The behavior
1962/// of the normalized residuals plot (see Fig. 1c) and the normal Q-Q plot
1963/// (see Fig. 1d) of residuals are regular and we cannot identify the outliers
1964/// or bins with a big influence on \f$ \chi^{2} \f$.
1965///
1966/// The second example presents the same two histograms but 17 events was added
1967/// to content of bin number 15 in unweighted histogram. Fig.2 shows the result
1968/// of comparison of the unweighted histogram with 217 events (minimal expected
1969/// frequency equal to one) and the weighted histogram with 500 events (minimal
1970/// expected frequency equal to 25)
1971/// Begin_Macro
1972/// ../../../tutorials/math/chi2test.C(17)
1973/// End_Macro
1974/// Fig 2. An example of comparison of the unweighted histogram with 217 events
1975/// and the weighted histogram with 500 events:
1976/// 1. unweighted histogram;
1977/// 2. weighted histogram;
1978/// 3. normalized residuals plot;
1979/// 4. normal Q-Q plot of residuals.
1980///
1981/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1982/// 32.33 with p-value equal to 0.029, therefore the hypothesis of identity of
1983/// the two histograms is rejected for 0.05 significant level. The behavior of
1984/// the normalized residuals plot (see Fig. 2c) and the normal Q-Q plot (see
1985/// Fig. 2d) of residuals are not regular and we can identify the outlier or
1986/// bin with a big influence on \f$ \chi^{2} \f$.
1987///
1988/// #### References:
1989///
1990/// - [1] Pearson, K., 1904. On the Theory of Contingency and Its Relation to
1991/// Association and Normal Correlation. Drapers' Co. Memoirs, Biometric
1992/// Series No. 1, London.
1993/// - [2] Gagunashvili, N., 2006. \f$ \sigma^{2} \f$ test for comparison
1994/// of weighted and unweighted histograms. Statistical Problems in Particle
1995/// Physics, Astrophysics and Cosmology, Proceedings of PHYSTAT05,
1996/// Oxford, UK, 12-15 September 2005, Imperial College Press, London, 43-44.
1997/// Gagunashvili,N., Comparison of weighted and unweighted histograms,
1998/// arXiv:physics/0605123, 2006.
1999/// - [3] Cramer, H., 1946. Mathematical methods of statistics.
2000/// Princeton University Press, Princeton.
2001/// - [4] Haberman, S.J., 1973. The analysis of residuals in cross-classified tables.
2002/// Biometrics 29, 205-220.
2003/// - [5] Lewontin, R.C. and Felsenstein, J., 1965. The robustness of homogeneity
2004/// test in 2xN tables. Biometrics 21, 19-33.
2005/// - [6] Seber, G.A.F., Lee, A.J., 2003, Linear Regression Analysis.
2006/// John Wiley & Sons Inc., New York.
2007
2008Double_t TH1::Chi2Test(const TH1* h2, Option_t *option, Double_t *res) const
2009{
2010 Double_t chi2 = 0;
2011 Int_t ndf = 0, igood = 0;
2012
2013 TString opt = option;
2014 opt.ToUpper();
2015
2016 Double_t prob = Chi2TestX(h2,chi2,ndf,igood,option,res);
2017
2018 if(opt.Contains("P")) {
2019 printf("Chi2 = %f, Prob = %g, NDF = %d, igood = %d\n", chi2,prob,ndf,igood);
2020 }
2021 if(opt.Contains("CHI2/NDF")) {
2022 if (ndf == 0) return 0;
2023 return chi2/ndf;
2024 }
2025 if(opt.Contains("CHI2")) {
2026 return chi2;
2027 }
2028
2029 return prob;
2030}
2031
2032////////////////////////////////////////////////////////////////////////////////
2033/// The computation routine of the Chisquare test. For the method description,
2034/// see Chi2Test() function.
2035///
2036/// \return p-value
2037/// \param[in] h2 the second histogram
2038/// \param[in] option
2039/// - "UU" = experiment experiment comparison (unweighted-unweighted)
2040/// - "UW" = experiment MC comparison (unweighted-weighted). Note that the first
2041/// histogram should be unweighted
2042/// - "WW" = MC MC comparison (weighted-weighted)
2043/// - "NORM" = if one or both histograms is scaled
2044/// - "OF" = overflows included
2045/// - "UF" = underflows included
2046/// by default underflows and overflows are not included
2047/// \param[out] igood test output
2048/// - igood=0 - no problems
2049/// - For unweighted unweighted comparison
2050/// - igood=1'There is a bin in the 1st histogram with less than 1 event'
2051/// - igood=2'There is a bin in the 2nd histogram with less than 1 event'
2052/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2053/// - For unweighted weighted comparison
2054/// - igood=1'There is a bin in the 1st histogram with less then 1 event'
2055/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective number of events'
2056/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2057/// - For weighted weighted comparison
2058/// - igood=1'There is a bin in the 1st histogram with less then 10 effective
2059/// number of events'
2060/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective
2061/// number of events'
2062/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2063/// \param[out] chi2 chisquare of the test
2064/// \param[out] ndf number of degrees of freedom (important, when both histograms have the same empty bins)
2065/// \param[out] res normalized residuals for further analysis
2066
2067Double_t TH1::Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option, Double_t *res) const
2068{
2069
2070 Int_t i_start, i_end;
2071 Int_t j_start, j_end;
2072 Int_t k_start, k_end;
2073
2074 Double_t sum1 = 0.0, sumw1 = 0.0;
2075 Double_t sum2 = 0.0, sumw2 = 0.0;
2076
2077 chi2 = 0.0;
2078 ndf = 0;
2079
2080 TString opt = option;
2081 opt.ToUpper();
2082
2083 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
2084
2085 const TAxis *xaxis1 = GetXaxis();
2086 const TAxis *xaxis2 = h2->GetXaxis();
2087 const TAxis *yaxis1 = GetYaxis();
2088 const TAxis *yaxis2 = h2->GetYaxis();
2089 const TAxis *zaxis1 = GetZaxis();
2090 const TAxis *zaxis2 = h2->GetZaxis();
2091
2092 Int_t nbinx1 = xaxis1->GetNbins();
2093 Int_t nbinx2 = xaxis2->GetNbins();
2094 Int_t nbiny1 = yaxis1->GetNbins();
2095 Int_t nbiny2 = yaxis2->GetNbins();
2096 Int_t nbinz1 = zaxis1->GetNbins();
2097 Int_t nbinz2 = zaxis2->GetNbins();
2098
2099 //check dimensions
2100 if (this->GetDimension() != h2->GetDimension() ){
2101 Error("Chi2TestX","Histograms have different dimensions.");
2102 return 0.0;
2103 }
2104
2105 //check number of channels
2106 if (nbinx1 != nbinx2) {
2107 Error("Chi2TestX","different number of x channels");
2108 }
2109 if (nbiny1 != nbiny2) {
2110 Error("Chi2TestX","different number of y channels");
2111 }
2112 if (nbinz1 != nbinz2) {
2113 Error("Chi2TestX","different number of z channels");
2114 }
2115
2116 //check for ranges
2117 i_start = j_start = k_start = 1;
2118 i_end = nbinx1;
2119 j_end = nbiny1;
2120 k_end = nbinz1;
2121
2122 if (xaxis1->TestBit(TAxis::kAxisRange)) {
2123 i_start = xaxis1->GetFirst();
2124 i_end = xaxis1->GetLast();
2125 }
2126 if (yaxis1->TestBit(TAxis::kAxisRange)) {
2127 j_start = yaxis1->GetFirst();
2128 j_end = yaxis1->GetLast();
2129 }
2130 if (zaxis1->TestBit(TAxis::kAxisRange)) {
2131 k_start = zaxis1->GetFirst();
2132 k_end = zaxis1->GetLast();
2133 }
2134
2135
2136 if (opt.Contains("OF")) {
2137 if (GetDimension() == 3) k_end = ++nbinz1;
2138 if (GetDimension() >= 2) j_end = ++nbiny1;
2139 if (GetDimension() >= 1) i_end = ++nbinx1;
2140 }
2141
2142 if (opt.Contains("UF")) {
2143 if (GetDimension() == 3) k_start = 0;
2144 if (GetDimension() >= 2) j_start = 0;
2145 if (GetDimension() >= 1) i_start = 0;
2146 }
2147
2148 ndf = (i_end - i_start + 1) * (j_end - j_start + 1) * (k_end - k_start + 1) - 1;
2149
2150 Bool_t comparisonUU = opt.Contains("UU");
2151 Bool_t comparisonUW = opt.Contains("UW");
2152 Bool_t comparisonWW = opt.Contains("WW");
2153 Bool_t scaledHistogram = opt.Contains("NORM");
2154
2155 if (scaledHistogram && !comparisonUU) {
2156 Info("Chi2TestX", "NORM option should be used together with UU option. It is ignored");
2157 }
2158
2159 // look at histo global bin content and effective entries
2160 Stat_t s[kNstat];
2161 GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2162 Double_t sumBinContent1 = s[0];
2163 Double_t effEntries1 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2164
2165 h2->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2166 Double_t sumBinContent2 = s[0];
2167 Double_t effEntries2 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2168
2169 if (!comparisonUU && !comparisonUW && !comparisonWW ) {
2170 // deduce automatically from type of histogram
2171 if (TMath::Abs(sumBinContent1 - effEntries1) < 1) {
2172 if ( TMath::Abs(sumBinContent2 - effEntries2) < 1) comparisonUU = true;
2173 else comparisonUW = true;
2174 }
2175 else comparisonWW = true;
2176 }
2177 // check unweighted histogram
2178 if (comparisonUW) {
2179 if (TMath::Abs(sumBinContent1 - effEntries1) >= 1) {
2180 Warning("Chi2TestX","First histogram is not unweighted and option UW has been requested");
2181 }
2182 }
2183 if ( (!scaledHistogram && comparisonUU) ) {
2184 if ( ( TMath::Abs(sumBinContent1 - effEntries1) >= 1) || (TMath::Abs(sumBinContent2 - effEntries2) >= 1) ) {
2185 Warning("Chi2TestX","Both histograms are not unweighted and option UU has been requested");
2186 }
2187 }
2188
2189
2190 //get number of events in histogram
2191 if (comparisonUU && scaledHistogram) {
2192 for (Int_t i = i_start; i <= i_end; ++i) {
2193 for (Int_t j = j_start; j <= j_end; ++j) {
2194 for (Int_t k = k_start; k <= k_end; ++k) {
2195
2196 Int_t bin = GetBin(i, j, k);
2197
2198 Double_t cnt1 = RetrieveBinContent(bin);
2199 Double_t cnt2 = h2->RetrieveBinContent(bin);
2200 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2201 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2202
2203 if (e1sq > 0.0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2204 else cnt1 = 0.0;
2205
2206 if (e2sq > 0.0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2207 else cnt2 = 0.0;
2208
2209 // sum contents
2210 sum1 += cnt1;
2211 sum2 += cnt2;
2212 sumw1 += e1sq;
2213 sumw2 += e2sq;
2214 }
2215 }
2216 }
2217 if (sumw1 <= 0.0 || sumw2 <= 0.0) {
2218 Error("Chi2TestX", "Cannot use option NORM when one histogram has all zero errors");
2219 return 0.0;
2220 }
2221
2222 } else {
2223 for (Int_t i = i_start; i <= i_end; ++i) {
2224 for (Int_t j = j_start; j <= j_end; ++j) {
2225 for (Int_t k = k_start; k <= k_end; ++k) {
2226
2227 Int_t bin = GetBin(i, j, k);
2228
2229 sum1 += RetrieveBinContent(bin);
2230 sum2 += h2->RetrieveBinContent(bin);
2231
2232 if ( comparisonWW ) sumw1 += GetBinErrorSqUnchecked(bin);
2233 if ( comparisonUW || comparisonWW ) sumw2 += h2->GetBinErrorSqUnchecked(bin);
2234 }
2235 }
2236 }
2237 }
2238 //checks that the histograms are not empty
2239 if (sum1 == 0.0 || sum2 == 0.0) {
2240 Error("Chi2TestX","one histogram is empty");
2241 return 0.0;
2242 }
2243
2244 if ( comparisonWW && ( sumw1 <= 0.0 && sumw2 <= 0.0 ) ){
2245 Error("Chi2TestX","Hist1 and Hist2 have both all zero errors\n");
2246 return 0.0;
2247 }
2248
2249 //THE TEST
2250 Int_t m = 0, n = 0;
2251
2252 //Experiment - experiment comparison
2253 if (comparisonUU) {
2254 Double_t sum = sum1 + sum2;
2255 for (Int_t i = i_start; i <= i_end; ++i) {
2256 for (Int_t j = j_start; j <= j_end; ++j) {
2257 for (Int_t k = k_start; k <= k_end; ++k) {
2258
2259 Int_t bin = GetBin(i, j, k);
2260
2261 Double_t cnt1 = RetrieveBinContent(bin);
2262 Double_t cnt2 = h2->RetrieveBinContent(bin);
2263
2264 if (scaledHistogram) {
2265 // scale bin value to effective bin entries
2266 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2267 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2268
2269 if (e1sq > 0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2270 else cnt1 = 0;
2271
2272 if (e2sq > 0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2273 else cnt2 = 0;
2274 }
2275
2276 if (Int_t(cnt1) == 0 && Int_t(cnt2) == 0) --ndf; // no data means one degree of freedom less
2277 else {
2278
2279 Double_t cntsum = cnt1 + cnt2;
2280 Double_t nexp1 = cntsum * sum1 / sum;
2281 //Double_t nexp2 = binsum*sum2/sum;
2282
2283 if (res) res[i - i_start] = (cnt1 - nexp1) / TMath::Sqrt(nexp1);
2284
2285 if (cnt1 < 1) ++m;
2286 if (cnt2 < 1) ++n;
2287
2288 //Habermann correction for residuals
2289 Double_t correc = (1. - sum1 / sum) * (1. - cntsum / sum);
2290 if (res) res[i - i_start] /= TMath::Sqrt(correc);
2291
2292 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2293 chi2 += delta * delta / cntsum;
2294 }
2295 }
2296 }
2297 }
2298 chi2 /= sum1 * sum2;
2299
2300 // flag error only when of the two histogram is zero
2301 if (m) {
2302 igood += 1;
2303 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2304 }
2305 if (n) {
2306 igood += 2;
2307 Info("Chi2TestX","There is a bin in h2 with less than 1 event.\n");
2308 }
2309
2310 Double_t prob = TMath::Prob(chi2,ndf);
2311 return prob;
2312
2313 }
2314
2315 // unweighted - weighted comparison
2316 // case of error = 0 and content not zero is treated without problems by excluding second chi2 sum
2317 // and can be considered as a data-theory comparison
2318 if ( comparisonUW ) {
2319 for (Int_t i = i_start; i <= i_end; ++i) {
2320 for (Int_t j = j_start; j <= j_end; ++j) {
2321 for (Int_t k = k_start; k <= k_end; ++k) {
2322
2323 Int_t bin = GetBin(i, j, k);
2324
2325 Double_t cnt1 = RetrieveBinContent(bin);
2326 Double_t cnt2 = h2->RetrieveBinContent(bin);
2327 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2328
2329 // case both histogram have zero bin contents
2330 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2331 --ndf; //no data means one degree of freedom less
2332 continue;
2333 }
2334
2335 // case weighted histogram has zero bin content and error
2336 if (cnt2 * cnt2 == 0 && e2sq == 0) {
2337 if (sumw2 > 0) {
2338 // use as approximated error as 1 scaled by a scaling ratio
2339 // estimated from the total sum weight and sum weight squared
2340 e2sq = sumw2 / sum2;
2341 }
2342 else {
2343 // return error because infinite discrepancy here:
2344 // bin1 != 0 and bin2 =0 in a histogram with all errors zero
2345 Error("Chi2TestX","Hist2 has in bin (%d,%d,%d) zero content and zero errors\n", i, j, k);
2346 chi2 = 0; return 0;
2347 }
2348 }
2349
2350 if (cnt1 < 1) m++;
2351 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2352
2353 Double_t var1 = sum2 * cnt2 - sum1 * e2sq;
2354 Double_t var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2355
2356 // if cnt1 is zero and cnt2 = 1 and sum1 = sum2 var1 = 0 && var2 == 0
2357 // approximate by incrementing cnt1
2358 // LM (this need to be fixed for numerical errors)
2359 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2360 sum1++;
2361 cnt1++;
2362 var1 = sum2 * cnt2 - sum1 * e2sq;
2363 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2364 }
2365 var2 = TMath::Sqrt(var2);
2366
2367 while (var1 + var2 == 0) {
2368 sum1++;
2369 cnt1++;
2370 var1 = sum2 * cnt2 - sum1 * e2sq;
2371 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2372 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2373 sum1++;
2374 cnt1++;
2375 var1 = sum2 * cnt2 - sum1 * e2sq;
2376 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2377 }
2378 var2 = TMath::Sqrt(var2);
2379 }
2380
2381 Double_t probb = (var1 + var2) / (2. * sum2 * sum2);
2382
2383 Double_t nexp1 = probb * sum1;
2384 Double_t nexp2 = probb * sum2;
2385
2386 Double_t delta1 = cnt1 - nexp1;
2387 Double_t delta2 = cnt2 - nexp2;
2388
2389 chi2 += delta1 * delta1 / nexp1;
2390
2391 if (e2sq > 0) {
2392 chi2 += delta2 * delta2 / e2sq;
2393 }
2394
2395 if (res) {
2396 if (e2sq > 0) {
2397 Double_t temp1 = sum2 * e2sq / var2;
2398 Double_t temp2 = 1.0 + (sum1 * e2sq - sum2 * cnt2) / var2;
2399 temp2 = temp1 * temp1 * sum1 * probb * (1.0 - probb) + temp2 * temp2 * e2sq / 4.0;
2400 // invert sign here
2401 res[i - i_start] = - delta2 / TMath::Sqrt(temp2);
2402 }
2403 else
2404 res[i - i_start] = delta1 / TMath::Sqrt(nexp1);
2405 }
2406 }
2407 }
2408 }
2409
2410 if (m) {
2411 igood += 1;
2412 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2413 }
2414 if (n) {
2415 igood += 2;
2416 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2417 }
2418
2419 Double_t prob = TMath::Prob(chi2, ndf);
2420
2421 return prob;
2422 }
2423
2424 // weighted - weighted comparison
2425 if (comparisonWW) {
2426 for (Int_t i = i_start; i <= i_end; ++i) {
2427 for (Int_t j = j_start; j <= j_end; ++j) {
2428 for (Int_t k = k_start; k <= k_end; ++k) {
2429
2430 Int_t bin = GetBin(i, j, k);
2431 Double_t cnt1 = RetrieveBinContent(bin);
2432 Double_t cnt2 = h2->RetrieveBinContent(bin);
2433 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2434 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2435
2436 // case both histogram have zero bin contents
2437 // (use square of content to avoid numerical errors)
2438 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2439 --ndf; //no data means one degree of freedom less
2440 continue;
2441 }
2442
2443 if (e1sq == 0 && e2sq == 0) {
2444 // cannot treat case of booth histogram have zero zero errors
2445 Error("Chi2TestX","h1 and h2 both have bin %d,%d,%d with all zero errors\n", i,j,k);
2446 chi2 = 0; return 0;
2447 }
2448
2449 Double_t sigma = sum1 * sum1 * e2sq + sum2 * sum2 * e1sq;
2450 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2451 chi2 += delta * delta / sigma;
2452
2453 if (res) {
2454 Double_t temp = cnt1 * sum1 * e2sq + cnt2 * sum2 * e1sq;
2455 Double_t probb = temp / sigma;
2456 Double_t z = 0;
2457 if (e1sq > e2sq) {
2458 Double_t d1 = cnt1 - sum1 * probb;
2459 Double_t s1 = e1sq * ( 1. - e2sq * sum1 * sum1 / sigma );
2460 z = d1 / TMath::Sqrt(s1);
2461 }
2462 else {
2463 Double_t d2 = cnt2 - sum2 * probb;
2464 Double_t s2 = e2sq * ( 1. - e1sq * sum2 * sum2 / sigma );
2465 z = -d2 / TMath::Sqrt(s2);
2466 }
2467 res[i - i_start] = z;
2468 }
2469
2470 if (e1sq > 0 && cnt1 * cnt1 / e1sq < 10) m++;
2471 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2472 }
2473 }
2474 }
2475 if (m) {
2476 igood += 1;
2477 Info("Chi2TestX","There is a bin in h1 with less than 10 effective events.\n");
2478 }
2479 if (n) {
2480 igood += 2;
2481 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2482 }
2483 Double_t prob = TMath::Prob(chi2, ndf);
2484 return prob;
2485 }
2486 return 0;
2487}
2488////////////////////////////////////////////////////////////////////////////////
2489/// Compute and return the chisquare of this histogram with respect to a function
2490/// The chisquare is computed by weighting each histogram point by the bin error
2491/// By default the full range of the histogram is used.
2492/// Use option "R" for restricting the chisquare calculation to the given range of the function
2493/// Use option "L" for using the chisquare based on the poisson likelihood (Baker-Cousins Chisquare)
2494
2495Double_t TH1::Chisquare(TF1 * func, Option_t *option) const
2496{
2497 if (!func) {
2498 Error("Chisquare","Function pointer is Null - return -1");
2499 return -1;
2500 }
2501
2502 TString opt(option); opt.ToUpper();
2503 bool useRange = opt.Contains("R");
2504 bool usePL = opt.Contains("L");
2505
2506 return ROOT::Fit::Chisquare(*this, *func, useRange, usePL);
2507}
2508
2509////////////////////////////////////////////////////////////////////////////////
2510/// Remove all the content from the underflow and overflow bins, without changing the number of entries
2511/// After calling this method, every undeflow and overflow bins will have content 0.0
2512/// The Sumw2 is also cleared, since there is no more content in the bins
2513
2515{
2516 for (Int_t bin = 0; bin < fNcells; ++bin)
2517 if (IsBinUnderflow(bin) || IsBinOverflow(bin)) {
2518 UpdateBinContent(bin, 0.0);
2519 if (fSumw2.fN) fSumw2.fArray[bin] = 0.0;
2520 }
2521}
2522
2523////////////////////////////////////////////////////////////////////////////////
2524/// Compute integral (cumulative sum of bins)
2525/// The result stored in fIntegral is used by the GetRandom functions.
2526/// This function is automatically called by GetRandom when the fIntegral
2527/// array does not exist or when the number of entries in the histogram
2528/// has changed since the previous call to GetRandom.
2529/// The resulting integral is normalized to 1
2530/// If the routine is called with the onlyPositive flag set an error will
2531/// be produced in case of negative bin content and a NaN value returned
2532
2534{
2535 if (fBuffer) BufferEmpty();
2536
2537 // delete previously computed integral (if any)
2538 if (fIntegral) delete [] fIntegral;
2539
2540 // - Allocate space to store the integral and compute integral
2541 Int_t nbinsx = GetNbinsX();
2542 Int_t nbinsy = GetNbinsY();
2543 Int_t nbinsz = GetNbinsZ();
2544 Int_t nbins = nbinsx * nbinsy * nbinsz;
2545
2546 fIntegral = new Double_t[nbins + 2];
2547 Int_t ibin = 0; fIntegral[ibin] = 0;
2548
2549 for (Int_t binz=1; binz <= nbinsz; ++binz) {
2550 for (Int_t biny=1; biny <= nbinsy; ++biny) {
2551 for (Int_t binx=1; binx <= nbinsx; ++binx) {
2552 ++ibin;
2553 Double_t y = RetrieveBinContent(GetBin(binx, biny, binz));
2554 if (onlyPositive && y < 0) {
2555 Error("ComputeIntegral","Bin content is negative - return a NaN value");
2556 fIntegral[nbins] = TMath::QuietNaN();
2557 break;
2558 }
2559 fIntegral[ibin] = fIntegral[ibin - 1] + y;
2560 }
2561 }
2562 }
2563
2564 // - Normalize integral to 1
2565 if (fIntegral[nbins] == 0 ) {
2566 Error("ComputeIntegral", "Integral = zero"); return 0;
2567 }
2568 for (Int_t bin=1; bin <= nbins; ++bin) fIntegral[bin] /= fIntegral[nbins];
2569 fIntegral[nbins+1] = fEntries;
2570 return fIntegral[nbins];
2571}
2572
2573////////////////////////////////////////////////////////////////////////////////
2574/// Return a pointer to the array of bins integral.
2575/// if the pointer fIntegral is null, TH1::ComputeIntegral is called
2576/// The array dimension is the number of bins in the histograms
2577/// including underflow and overflow (fNCells)
2578/// the last value integral[fNCells] is set to the number of entries of
2579/// the histogram
2580
2582{
2583 if (!fIntegral) ComputeIntegral();
2584 return fIntegral;
2585}
2586
2587////////////////////////////////////////////////////////////////////////////////
2588/// Return a pointer to an histogram containing the cumulative content.
2589/// The cumulative can be computed both in the forward (default) or backward
2590/// direction; the name of the new histogram is constructed from
2591/// the name of this histogram with the suffix "suffix" appended provided
2592/// by the user. If not provided a default suffix="_cumulative" is used.
2593///
2594/// The cumulative distribution is formed by filling each bin of the
2595/// resulting histogram with the sum of that bin and all previous
2596/// (forward == kTRUE) or following (forward = kFALSE) bins.
2597///
2598/// Note: while cumulative distributions make sense in one dimension, you
2599/// may not be getting what you expect in more than 1D because the concept
2600/// of a cumulative distribution is much trickier to define; make sure you
2601/// understand the order of summation before you use this method with
2602/// histograms of dimension >= 2.
2603///
2604/// Note 2: By default the cumulative is computed from bin 1 to Nbins
2605/// If an axis range is set, values between the minimum and maximum of the range
2606/// are set.
2607/// Setting an axis range can also be used for including underflow and overflow in
2608/// the cumulative (e.g. by setting h->GetXaxis()->SetRange(0, h->GetNbinsX()+1); )
2610
2611TH1 *TH1::GetCumulative(Bool_t forward, const char* suffix) const
2612{
2613 const Int_t firstX = fXaxis.GetFirst();
2614 const Int_t lastX = fXaxis.GetLast();
2615 const Int_t firstY = (fDimension > 1) ? fYaxis.GetFirst() : 1;
2616 const Int_t lastY = (fDimension > 1) ? fYaxis.GetLast() : 1;
2617 const Int_t firstZ = (fDimension > 1) ? fZaxis.GetFirst() : 1;
2618 const Int_t lastZ = (fDimension > 1) ? fZaxis.GetLast() : 1;
2619
2620 TH1* hintegrated = (TH1*) Clone(fName + suffix);
2621 hintegrated->Reset();
2622 Double_t sum = 0.;
2623 Double_t esum = 0;
2624 if (forward) { // Forward computation
2625 for (Int_t binz = firstZ; binz <= lastZ; ++binz) {
2626 for (Int_t biny = firstY; biny <= lastY; ++biny) {
2627 for (Int_t binx = firstX; binx <= lastX; ++binx) {
2628 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2629 sum += RetrieveBinContent(bin);
2630 hintegrated->AddBinContent(bin, sum);
2631 if (fSumw2.fN) {
2632 esum += GetBinErrorSqUnchecked(bin);
2633 fSumw2.fArray[bin] = esum;
2634 }
2635 }
2636 }
2637 }
2638 } else { // Backward computation
2639 for (Int_t binz = lastZ; binz >= firstZ; --binz) {
2640 for (Int_t biny = lastY; biny >= firstY; --biny) {
2641 for (Int_t binx = lastX; binx >= firstX; --binx) {
2642 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2643 sum += RetrieveBinContent(bin);
2644 hintegrated->AddBinContent(bin, sum);
2645 if (fSumw2.fN) {
2646 esum += GetBinErrorSqUnchecked(bin);
2647 fSumw2.fArray[bin] = esum;
2648 }
2649 }
2650 }
2651 }
2652 }
2653 return hintegrated;
2654}
2655
2656////////////////////////////////////////////////////////////////////////////////
2657/// Copy this histogram structure to newth1.
2658///
2659/// Note that this function does not copy the list of associated functions.
2660/// Use TObject::Clone to make a full copy of an histogram.
2661///
2662/// Note also that the histogram it will be created in gDirectory (if AddDirectoryStatus()=true)
2663/// or will not be added to any directory if AddDirectoryStatus()=false
2664/// independently of the current directory stored in the original histogram
2665
2666void TH1::Copy(TObject &obj) const
2667{
2668 if (((TH1&)obj).fDirectory) {
2669 // We are likely to change the hash value of this object
2670 // with TNamed::Copy, to keep things correct, we need to
2671 // clean up its existing entries.
2672 ((TH1&)obj).fDirectory->Remove(&obj);
2673 ((TH1&)obj).fDirectory = 0;
2674 }
2675 TNamed::Copy(obj);
2676 ((TH1&)obj).fDimension = fDimension;
2677 ((TH1&)obj).fNormFactor= fNormFactor;
2678 ((TH1&)obj).fNcells = fNcells;
2679 ((TH1&)obj).fBarOffset = fBarOffset;
2680 ((TH1&)obj).fBarWidth = fBarWidth;
2681 ((TH1&)obj).fOption = fOption;
2682 ((TH1&)obj).fBinStatErrOpt = fBinStatErrOpt;
2683 ((TH1&)obj).fBufferSize= fBufferSize;
2684 // copy the Buffer
2685 // delete first a previously existing buffer
2686 if (((TH1&)obj).fBuffer != 0) {
2687 delete [] ((TH1&)obj).fBuffer;
2688 ((TH1&)obj).fBuffer = 0;
2689 }
2690 if (fBuffer) {
2691 Double_t *buf = new Double_t[fBufferSize];
2692 for (Int_t i=0;i<fBufferSize;i++) buf[i] = fBuffer[i];
2693 // obj.fBuffer has been deleted before
2694 ((TH1&)obj).fBuffer = buf;
2695 }
2696
2697
2698 TArray* a = dynamic_cast<TArray*>(&obj);
2699 if (a) a->Set(fNcells);
2700 for (Int_t i = 0; i < fNcells; i++) ((TH1&)obj).UpdateBinContent(i, RetrieveBinContent(i));
2701
2702 ((TH1&)obj).fEntries = fEntries;
2703
2704 // which will call BufferEmpty(0) and set fBuffer[0] to a Maybe one should call
2705 // assignment operator on the TArrayD
2706
2707 ((TH1&)obj).fTsumw = fTsumw;
2708 ((TH1&)obj).fTsumw2 = fTsumw2;
2709 ((TH1&)obj).fTsumwx = fTsumwx;
2710 ((TH1&)obj).fTsumwx2 = fTsumwx2;
2711 ((TH1&)obj).fMaximum = fMaximum;
2712 ((TH1&)obj).fMinimum = fMinimum;
2713
2714 TAttLine::Copy(((TH1&)obj));
2715 TAttFill::Copy(((TH1&)obj));
2716 TAttMarker::Copy(((TH1&)obj));
2717 fXaxis.Copy(((TH1&)obj).fXaxis);
2718 fYaxis.Copy(((TH1&)obj).fYaxis);
2719 fZaxis.Copy(((TH1&)obj).fZaxis);
2720 ((TH1&)obj).fXaxis.SetParent(&obj);
2721 ((TH1&)obj).fYaxis.SetParent(&obj);
2722 ((TH1&)obj).fZaxis.SetParent(&obj);
2723 fContour.Copy(((TH1&)obj).fContour);
2724 fSumw2.Copy(((TH1&)obj).fSumw2);
2725 // fFunctions->Copy(((TH1&)obj).fFunctions);
2726 // when copying an histogram if the AddDirectoryStatus() is true it
2727 // will be added to gDirectory independently of the fDirectory stored.
2728 // and if the AddDirectoryStatus() is false it will not be added to
2729 // any directory (fDirectory = 0)
2730 if (fgAddDirectory && gDirectory) {
2731 gDirectory->Append(&obj);
2732 ((TH1&)obj).fFunctions->UseRWLock();
2733 ((TH1&)obj).fDirectory = gDirectory;
2734 } else
2735 ((TH1&)obj).fDirectory = 0;
2736
2737}
2738
2739////////////////////////////////////////////////////////////////////////////////
2740/// Make a complete copy of the underlying object. If 'newname' is set,
2741/// the copy's name will be set to that name.
2742
2743TObject* TH1::Clone(const char* newname) const
2744{
2745 TH1* obj = (TH1*)IsA()->GetNew()(0);
2746 Copy(*obj);
2747
2748 // Now handle the parts that Copy doesn't do
2749 if(fFunctions) {
2750 // The Copy above might have published 'obj' to the ListOfCleanups.
2751 // Clone can call RecursiveRemove, for example via TCheckHashRecursiveRemoveConsistency
2752 // when dictionary information is initialized, so we need to
2753 // keep obj->fFunction valid during its execution and
2754 // protect the update with the write lock.
2755
2756 // Reset stats parent - else cloning the stats will clone this histogram, too.
2757 auto oldstats = dynamic_cast<TVirtualPaveStats*>(fFunctions->FindObject("stats"));
2758 TObject *oldparent = nullptr;
2759 if (oldstats) {
2760 oldparent = oldstats->GetParent();
2761 oldstats->SetParent(nullptr);
2762 }
2763
2764 auto newlist = (TList*)fFunctions->Clone();
2765
2766 if (oldstats)
2767 oldstats->SetParent(oldparent);
2768 auto newstats = dynamic_cast<TVirtualPaveStats*>(obj->fFunctions->FindObject("stats"));
2769 if (newstats)
2770 newstats->SetParent(obj);
2771
2772 auto oldlist = obj->fFunctions;
2773 {
2775 obj->fFunctions = newlist;
2776 }
2777 delete oldlist;
2778 }
2779 if(newname && strlen(newname) ) {
2780 obj->SetName(newname);
2781 }
2782 return obj;
2783}
2784
2785////////////////////////////////////////////////////////////////////////////////
2786/// Perform the automatic addition of the histogram to the given directory
2787///
2788/// Note this function is called in place when the semantic requires
2789/// this object to be added to a directory (I.e. when being read from
2790/// a TKey or being Cloned)
2791
2793{
2794 Bool_t addStatus = TH1::AddDirectoryStatus();
2795 if (addStatus) {
2796 SetDirectory(dir);
2797 if (dir) {
2799 }
2800 }
2801}
2802
2803////////////////////////////////////////////////////////////////////////////////
2804/// Compute distance from point px,py to a line.
2805///
2806/// Compute the closest distance of approach from point px,py to elements
2807/// of an histogram.
2808/// The distance is computed in pixels units.
2809///
2810/// #### Algorithm:
2811/// Currently, this simple model computes the distance from the mouse
2812/// to the histogram contour only.
2813
2815{
2816 if (!fPainter) return 9999;
2817 return fPainter->DistancetoPrimitive(px,py);
2818}
2819
2820////////////////////////////////////////////////////////////////////////////////
2821/// Performs the operation: `this = this/(c1*f1)`
2822/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2823///
2824/// Only bins inside the function range are recomputed.
2825/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2826/// you should call Sumw2 before making this operation.
2827/// This is particularly important if you fit the histogram after TH1::Divide
2828///
2829/// The function return kFALSE if the divide operation failed
2830
2832{
2833 if (!f1) {
2834 Error("Divide","Attempt to divide by a non-existing function");
2835 return kFALSE;
2836 }
2837
2838 // delete buffer if it is there since it will become invalid
2839 if (fBuffer) BufferEmpty(1);
2840
2841 Int_t nx = GetNbinsX() + 2; // normal bins + uf / of
2842 Int_t ny = GetNbinsY() + 2;
2843 Int_t nz = GetNbinsZ() + 2;
2844 if (fDimension < 2) ny = 1;
2845 if (fDimension < 3) nz = 1;
2846
2847
2848 SetMinimum();
2849 SetMaximum();
2850
2851 // - Loop on bins (including underflows/overflows)
2852 Int_t bin, binx, biny, binz;
2853 Double_t cu, w;
2854 Double_t xx[3];
2855 Double_t *params = 0;
2856 f1->InitArgs(xx,params);
2857 for (binz = 0; binz < nz; ++binz) {
2858 xx[2] = fZaxis.GetBinCenter(binz);
2859 for (biny = 0; biny < ny; ++biny) {
2860 xx[1] = fYaxis.GetBinCenter(biny);
2861 for (binx = 0; binx < nx; ++binx) {
2862 xx[0] = fXaxis.GetBinCenter(binx);
2863 if (!f1->IsInside(xx)) continue;
2865 bin = binx + nx * (biny + ny * binz);
2866 cu = c1 * f1->EvalPar(xx);
2867 if (TF1::RejectedPoint()) continue;
2868 if (cu) w = RetrieveBinContent(bin) / cu;
2869 else w = 0;
2870 UpdateBinContent(bin, w);
2871 if (fSumw2.fN) {
2872 if (cu != 0) fSumw2.fArray[bin] = GetBinErrorSqUnchecked(bin) / (cu * cu);
2873 else fSumw2.fArray[bin] = 0;
2874 }
2875 }
2876 }
2877 }
2878 ResetStats();
2879 return kTRUE;
2880}
2881
2882////////////////////////////////////////////////////////////////////////////////
2883/// Divide this histogram by h1.
2884///
2885/// `this = this/h1`
2886/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2887/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
2888/// if not already set.
2889/// The resulting errors are calculated assuming uncorrelated histograms.
2890/// See the other TH1::Divide that gives the possibility to optionally
2891/// compute binomial errors.
2892///
2893/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2894/// you should call Sumw2 before making this operation.
2895/// This is particularly important if you fit the histogram after TH1::Scale
2896///
2897/// The function return kFALSE if the divide operation failed
2898
2899Bool_t TH1::Divide(const TH1 *h1)
2900{
2901 if (!h1) {
2902 Error("Divide", "Input histogram passed does not exist (NULL).");
2903 return kFALSE;
2904 }
2905
2906 // delete buffer if it is there since it will become invalid
2907 if (fBuffer) BufferEmpty(1);
2908
2909 try {
2910 CheckConsistency(this,h1);
2911 } catch(DifferentNumberOfBins&) {
2912 Error("Divide","Cannot divide histograms with different number of bins");
2913 return kFALSE;
2914 } catch(DifferentAxisLimits&) {
2915 Warning("Divide","Dividing histograms with different axis limits");
2916 } catch(DifferentBinLimits&) {
2917 Warning("Divide","Dividing histograms with different bin limits");
2918 } catch(DifferentLabels&) {
2919 Warning("Divide","Dividing histograms with different labels");
2920 }
2921
2922 // Create Sumw2 if h1 has Sumw2 set
2923 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
2924
2925 // - Loop on bins (including underflows/overflows)
2926 for (Int_t i = 0; i < fNcells; ++i) {
2929 if (c1) UpdateBinContent(i, c0 / c1);
2930 else UpdateBinContent(i, 0);
2931
2932 if(fSumw2.fN) {
2933 if (c1 == 0) { fSumw2.fArray[i] = 0; continue; }
2934 Double_t c1sq = c1 * c1;
2935 fSumw2.fArray[i] = (GetBinErrorSqUnchecked(i) * c1sq + h1->GetBinErrorSqUnchecked(i) * c0 * c0) / (c1sq * c1sq);
2936 }
2937 }
2938 ResetStats();
2939 return kTRUE;
2940}
2941
2942////////////////////////////////////////////////////////////////////////////////
2943/// Replace contents of this histogram by the division of h1 by h2.
2944///
2945/// `this = c1*h1/(c2*h2)`
2946///
2947/// If errors are defined (see TH1::Sumw2), errors are also recalculated
2948/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
2949/// if not already set.
2950/// The resulting errors are calculated assuming uncorrelated histograms.
2951/// However, if option ="B" is specified, Binomial errors are computed.
2952/// In this case c1 and c2 do not make real sense and they are ignored.
2953///
2954/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2955/// you should call Sumw2 before making this operation.
2956/// This is particularly important if you fit the histogram after TH1::Divide
2957///
2958/// Please note also that in the binomial case errors are calculated using standard
2959/// binomial statistics, which means when b1 = b2, the error is zero.
2960/// If you prefer to have efficiency errors not going to zero when the efficiency is 1, you must
2961/// use the function TGraphAsymmErrors::BayesDivide, which will return an asymmetric and non-zero lower
2962/// error for the case b1=b2.
2963///
2964/// The function return kFALSE if the divide operation failed
2965
2966Bool_t TH1::Divide(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t *option)
2967{
2968
2969 TString opt = option;
2970 opt.ToLower();
2971 Bool_t binomial = kFALSE;
2972 if (opt.Contains("b")) binomial = kTRUE;
2973 if (!h1 || !h2) {
2974 Error("Divide", "At least one of the input histograms passed does not exist (NULL).");
2975 return kFALSE;
2976 }
2977
2978 // delete buffer if it is there since it will become invalid
2979 if (fBuffer) BufferEmpty(1);
2980
2981 try {
2982 CheckConsistency(h1,h2);
2983 CheckConsistency(this,h1);
2984 } catch(DifferentNumberOfBins&) {
2985 Error("Divide","Cannot divide histograms with different number of bins");
2986 return kFALSE;
2987 } catch(DifferentAxisLimits&) {
2988 Warning("Divide","Dividing histograms with different axis limits");
2989 } catch(DifferentBinLimits&) {
2990 Warning("Divide","Dividing histograms with different bin limits");
2991 } catch(DifferentLabels&) {
2992 Warning("Divide","Dividing histograms with different labels");
2993 }
2994
2995
2996 if (!c2) {
2997 Error("Divide","Coefficient of dividing histogram cannot be zero");
2998 return kFALSE;
2999 }
3000
3001 // Create Sumw2 if h1 or h2 have Sumw2 set, or if binomial errors are explicitly requested
3002 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0 || binomial)) Sumw2();
3003
3004 SetMinimum();
3005 SetMaximum();
3006
3007 // - Loop on bins (including underflows/overflows)
3008 for (Int_t i = 0; i < fNcells; ++i) {
3010 Double_t b2 = h2->RetrieveBinContent(i);
3011 if (b2) UpdateBinContent(i, c1 * b1 / (c2 * b2));
3012 else UpdateBinContent(i, 0);
3013
3014 if (fSumw2.fN) {
3015 if (b2 == 0) { fSumw2.fArray[i] = 0; continue; }
3016 Double_t b1sq = b1 * b1; Double_t b2sq = b2 * b2;
3017 Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
3019 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
3020 if (binomial) {
3021 if (b1 != b2) {
3022 // in the case of binomial statistics c1 and c2 must be 1 otherwise it does not make sense
3023 // c1 and c2 are ignored
3024 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));//this is the formula in Hbook/Hoper1
3025 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/b2); // old formula from G. Flucke
3026 // formula which works also for weighted histogram (see http://root-forum.cern.ch/viewtopic.php?t=3753 )
3027 fSumw2.fArray[i] = TMath::Abs( ( (1. - 2.* b1 / b2) * e1sq + b1sq * e2sq / b2sq ) / b2sq );
3028 } else {
3029 //in case b1=b2 error is zero
3030 //use TGraphAsymmErrors::BayesDivide for getting the asymmetric error not equal to zero
3031 fSumw2.fArray[i] = 0;
3032 }
3033 } else {
3034 fSumw2.fArray[i] = c1sq * c2sq * (e1sq * b2sq + e2sq * b1sq) / (c2sq * c2sq * b2sq * b2sq);
3035 }
3036 }
3037 }
3038 ResetStats();
3039 if (binomial)
3040 // in case of binomial division use denominator for number of entries
3041 SetEntries ( h2->GetEntries() );
3042
3043 return kTRUE;
3044}
3045
3046////////////////////////////////////////////////////////////////////////////////
3047/// Draw this histogram with options.
3048///
3049/// Histograms are drawn via the THistPainter class. Each histogram has
3050/// a pointer to its own painter (to be usable in a multithreaded program).
3051/// The same histogram can be drawn with different options in different pads.
3052/// When an histogram drawn in a pad is deleted, the histogram is
3053/// automatically removed from the pad or pads where it was drawn.
3054/// If an histogram is drawn in a pad, then filled again, the new status
3055/// of the histogram will be automatically shown in the pad next time
3056/// the pad is updated. One does not need to redraw the histogram.
3057/// To draw the current version of an histogram in a pad, one can use
3058/// `h->DrawCopy();`
3059/// This makes a clone of the histogram. Once the clone is drawn, the original
3060/// histogram may be modified or deleted without affecting the aspect of the
3061/// clone.
3062/// By default, TH1::Draw clears the current pad.
3063///
3064/// One can use TH1::SetMaximum and TH1::SetMinimum to force a particular
3065/// value for the maximum or the minimum scale on the plot.
3066///
3067/// TH1::UseCurrentStyle can be used to change all histogram graphics
3068/// attributes to correspond to the current selected style.
3069/// This function must be called for each histogram.
3070/// In case one reads and draws many histograms from a file, one can force
3071/// the histograms to inherit automatically the current graphics style
3072/// by calling before gROOT->ForceStyle();
3073///
3074/// See the THistPainter class for a description of all the drawing options.
3075
3076void TH1::Draw(Option_t *option)
3077{
3078 TString opt1 = option; opt1.ToLower();
3079 TString opt2 = option;
3080 Int_t index = opt1.Index("same");
3081
3082 // Check if the string "same" is part of a TCutg name.
3083 if (index>=0) {
3084 Int_t indb = opt1.Index("[");
3085 if (indb>=0) {
3086 Int_t indk = opt1.Index("]");
3087 if (index>indb && index<indk) index = -1;
3088 }
3089 }
3090
3091 // If there is no pad or an empty pad the "same" option is ignored.
3092 if (gPad) {
3093 if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
3094 if (index>=0) {
3095 if (gPad->GetX1() == 0 && gPad->GetX2() == 1 &&
3096 gPad->GetY1() == 0 && gPad->GetY2() == 1 &&
3097 gPad->GetListOfPrimitives()->GetSize()==0) opt2.Remove(index,4);
3098 } else {
3099 //the following statement is necessary in case one attempts to draw
3100 //a temporary histogram already in the current pad
3101 if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this);
3102 gPad->Clear();
3103 }
3104 gPad->IncrementPaletteColor(1, opt1);
3105 } else {
3106 if (index>=0) opt2.Remove(index,4);
3107 }
3108
3109 AppendPad(opt2.Data());
3110}
3111
3112////////////////////////////////////////////////////////////////////////////////
3113/// Copy this histogram and Draw in the current pad.
3114///
3115/// Once the histogram is drawn into the pad, any further modification
3116/// using graphics input will be made on the copy of the histogram,
3117/// and not to the original object.
3118/// By default a postfix "_copy" is added to the histogram name. Pass an empty postfix in case
3119/// you want to draw an histogram with the same name
3120///
3121/// See Draw for the list of options
3122
3123TH1 *TH1::DrawCopy(Option_t *option, const char * name_postfix) const
3124{
3125 TString opt = option;
3126 opt.ToLower();
3127 if (gPad && !opt.Contains("same")) gPad->Clear();
3128 TString newName = (name_postfix) ? TString::Format("%s%s",GetName(),name_postfix) : "";
3129 TH1 *newth1 = (TH1 *)Clone(newName);
3130 newth1->SetDirectory(0);
3131 newth1->SetBit(kCanDelete);
3132 if (gPad) gPad->IncrementPaletteColor(1, opt);
3133
3134 newth1->AppendPad(option);
3135 return newth1;
3136}
3137
3138////////////////////////////////////////////////////////////////////////////////
3139/// Draw a normalized copy of this histogram.
3140///
3141/// A clone of this histogram is normalized to norm and drawn with option.
3142/// A pointer to the normalized histogram is returned.
3143/// The contents of the histogram copy are scaled such that the new
3144/// sum of weights (excluding under and overflow) is equal to norm.
3145/// Note that the returned normalized histogram is not added to the list
3146/// of histograms in the current directory in memory.
3147/// It is the user's responsibility to delete this histogram.
3148/// The kCanDelete bit is set for the returned object. If a pad containing
3149/// this copy is cleared, the histogram will be automatically deleted.
3150///
3151/// See Draw for the list of options
3152
3153TH1 *TH1::DrawNormalized(Option_t *option, Double_t norm) const
3154{
3156 if (sum == 0) {
3157 Error("DrawNormalized","Sum of weights is null. Cannot normalize histogram: %s",GetName());
3158 return 0;
3159 }
3160 Bool_t addStatus = TH1::AddDirectoryStatus();
3162 TH1 *h = (TH1*)Clone();
3163 h->SetBit(kCanDelete);
3164 // in case of drawing with error options - scale correctly the error
3165 TString opt(option); opt.ToUpper();
3166 if (fSumw2.fN == 0) {
3167 h->Sumw2();
3168 // do not use in this case the "Error option " for drawing which is enabled by default since the normalized histogram has now errors
3169 if (opt.IsNull() || opt == "SAME") opt += "HIST";
3170 }
3171 h->Scale(norm/sum);
3172 if (TMath::Abs(fMaximum+1111) > 1e-3) h->SetMaximum(fMaximum*norm/sum);
3173 if (TMath::Abs(fMinimum+1111) > 1e-3) h->SetMinimum(fMinimum*norm/sum);
3174 h->Draw(opt);
3175 TH1::AddDirectory(addStatus);
3176 return h;
3177}
3178
3179////////////////////////////////////////////////////////////////////////////////
3180/// Display a panel with all histogram drawing options.
3181///
3182/// See class TDrawPanelHist for example
3183
3184void TH1::DrawPanel()
3185{
3186 if (!fPainter) {Draw(); if (gPad) gPad->Update();}
3187 if (fPainter) fPainter->DrawPanel();
3188}
3189
3190////////////////////////////////////////////////////////////////////////////////
3191/// Evaluate function f1 at the center of bins of this histogram.
3192///
3193/// - If option "R" is specified, the function is evaluated only
3194/// for the bins included in the function range.
3195/// - If option "A" is specified, the value of the function is added to the
3196/// existing bin contents
3197/// - If option "S" is specified, the value of the function is used to
3198/// generate a value, distributed according to the Poisson
3199/// distribution, with f1 as the mean.
3200
3201void TH1::Eval(TF1 *f1, Option_t *option)
3202{
3203 Double_t x[3];
3204 Int_t range, stat, add;
3205 if (!f1) return;
3206
3207 TString opt = option;
3208 opt.ToLower();
3209 if (opt.Contains("a")) add = 1;
3210 else add = 0;
3211 if (opt.Contains("s")) stat = 1;
3212 else stat = 0;
3213 if (opt.Contains("r")) range = 1;
3214 else range = 0;
3215
3216 // delete buffer if it is there since it will become invalid
3217 if (fBuffer) BufferEmpty(1);
3218
3219 Int_t nbinsx = fXaxis.GetNbins();
3220 Int_t nbinsy = fYaxis.GetNbins();
3221 Int_t nbinsz = fZaxis.GetNbins();
3222 if (!add) Reset();
3223
3224 for (Int_t binz = 1; binz <= nbinsz; ++binz) {
3225 x[2] = fZaxis.GetBinCenter(binz);
3226 for (Int_t biny = 1; biny <= nbinsy; ++biny) {
3227 x[1] = fYaxis.GetBinCenter(biny);
3228 for (Int_t binx = 1; binx <= nbinsx; ++binx) {
3229 Int_t bin = GetBin(binx,biny,binz);
3230 x[0] = fXaxis.GetBinCenter(binx);
3231 if (range && !f1->IsInside(x)) continue;
3232 Double_t fu = f1->Eval(x[0], x[1], x[2]);
3233 if (stat) fu = gRandom->PoissonD(fu);
3234 AddBinContent(bin, fu);
3235 if (fSumw2.fN) fSumw2.fArray[bin] += TMath::Abs(fu);
3236 }
3237 }
3238 }
3239}
3240
3241////////////////////////////////////////////////////////////////////////////////
3242/// Execute action corresponding to one event.
3243///
3244/// This member function is called when a histogram is clicked with the locator
3245///
3246/// If Left button clicked on the bin top value, then the content of this bin
3247/// is modified according to the new position of the mouse when it is released.
3248
3250{
3251 if (fPainter) fPainter->ExecuteEvent(event, px, py);
3252}
3253
3254////////////////////////////////////////////////////////////////////////////////
3255/// This function allows to do discrete Fourier transforms of TH1 and TH2.
3256/// Available transform types and flags are described below.
3257///
3258/// To extract more information about the transform, use the function
3259/// TVirtualFFT::GetCurrentTransform() to get a pointer to the current
3260/// transform object.
3261///
3262/// \param[out] h_output histogram for the output. If a null pointer is passed, a new histogram is created
3263/// and returned, otherwise, the provided histogram is used and should be big enough
3264/// \param[in] option option parameters consists of 3 parts:
3265/// - option on what to return
3266/// - "RE" - returns a histogram of the real part of the output
3267/// - "IM" - returns a histogram of the imaginary part of the output
3268/// - "MAG"- returns a histogram of the magnitude of the output
3269/// - "PH" - returns a histogram of the phase of the output
3270/// - option of transform type
3271/// - "R2C" - real to complex transforms - default
3272/// - "R2HC" - real to halfcomplex (special format of storing output data,
3273/// results the same as for R2C)
3274/// - "DHT" - discrete Hartley transform
3275/// real to real transforms (sine and cosine):
3276/// - "R2R_0", "R2R_1", "R2R_2", "R2R_3" - discrete cosine transforms of types I-IV
3277/// - "R2R_4", "R2R_5", "R2R_6", "R2R_7" - discrete sine transforms of types I-IV
3278/// To specify the type of each dimension of a 2-dimensional real to real
3279/// transform, use options of form "R2R_XX", for example, "R2R_02" for a transform,
3280/// which is of type "R2R_0" in 1st dimension and "R2R_2" in the 2nd.
3281/// - option of transform flag
3282/// - "ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal
3283/// performance
3284/// - "M" (from "measure") - some time spend in finding the optimal way to do the transform
3285/// - "P" (from "patient") - more time spend in finding the optimal way to do the transform
3286/// - "EX" (from "exhaustive") - the most optimal way is found
3287/// This option should be chosen depending on how many transforms of the same size and
3288/// type are going to be done. Planning is only done once, for the first transform of this
3289/// size and type. Default is "ES".
3290///
3291/// Examples of valid options: "Mag R2C M" "Re R2R_11" "Im R2C ES" "PH R2HC EX"
3292
3293TH1* TH1::FFT(TH1* h_output, Option_t *option)
3294{
3295
3296 Int_t ndim[3];
3297 ndim[0] = this->GetNbinsX();
3298 ndim[1] = this->GetNbinsY();
3299 ndim[2] = this->GetNbinsZ();
3300
3301 TVirtualFFT *fft;
3302 TString opt = option;
3303 opt.ToUpper();
3304 if (!opt.Contains("2R")){
3305 if (!opt.Contains("2C") && !opt.Contains("2HC") && !opt.Contains("DHT")) {
3306 //no type specified, "R2C" by default
3307 opt.Append("R2C");
3308 }
3309 fft = TVirtualFFT::FFT(this->GetDimension(), ndim, opt.Data());
3310 }
3311 else {
3312 //find the kind of transform
3313 Int_t ind = opt.Index("R2R", 3);
3314 Int_t *kind = new Int_t[2];
3315 char t;
3316 t = opt[ind+4];
3317 kind[0] = atoi(&t);
3318 if (h_output->GetDimension()>1) {
3319 t = opt[ind+5];
3320 kind[1] = atoi(&t);
3321 }
3322 fft = TVirtualFFT::SineCosine(this->GetDimension(), ndim, kind, option);
3323 delete [] kind;
3324 }
3325
3326 if (!fft) return 0;
3327 Int_t in=0;
3328 for (Int_t binx = 1; binx<=ndim[0]; binx++) {
3329 for (Int_t biny=1; biny<=ndim[1]; biny++) {
3330 for (Int_t binz=1; binz<=ndim[2]; binz++) {
3331 fft->SetPoint(in, this->GetBinContent(binx, biny, binz));
3332 in++;
3333 }
3334 }
3335 }
3336 fft->Transform();
3337 h_output = TransformHisto(fft, h_output, option);
3338 return h_output;
3339}
3340
3341////////////////////////////////////////////////////////////////////////////////
3342/// Increment bin with abscissa X by 1.
3343///
3344/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3345/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3346///
3347/// If the storage of the sum of squares of weights has been triggered,
3348/// via the function Sumw2, then the sum of the squares of weights is incremented
3349/// by 1 in the bin corresponding to x.
3350///
3351/// The function returns the corresponding bin number which has its content incremented by 1
3352
3354{
3355 if (fBuffer) return BufferFill(x,1);
3356
3357 Int_t bin;
3358 fEntries++;
3359 bin =fXaxis.FindBin(x);
3360 if (bin <0) return -1;
3361 AddBinContent(bin);
3362 if (fSumw2.fN) ++fSumw2.fArray[bin];
3363 if (bin == 0 || bin > fXaxis.GetNbins()) {
3364 if (!GetStatOverflowsBehaviour()) return -1;
3365 }
3366 ++fTsumw;
3367 ++fTsumw2;
3368 fTsumwx += x;
3369 fTsumwx2 += x*x;
3370 return bin;
3371}
3372
3373////////////////////////////////////////////////////////////////////////////////
3374/// Increment bin with abscissa X with a weight w.
3375///
3376/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3377/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3378///
3379/// If the weight is not equal to 1, the storage of the sum of squares of
3380/// weights is automatically triggered and the sum of the squares of weights is incremented
3381/// by \f$ w^2 \f$ in the bin corresponding to x.
3382///
3383/// The function returns the corresponding bin number which has its content incremented by w
3384
3386{
3387
3388 if (fBuffer) return BufferFill(x,w);
3389
3390 Int_t bin;
3391 fEntries++;
3392 bin =fXaxis.FindBin(x);
3393 if (bin <0) return -1;
3394 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW) ) Sumw2(); // must be called before AddBinContent
3395 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3396 AddBinContent(bin, w);
3397 if (bin == 0 || bin > fXaxis.GetNbins()) {
3398 if (!GetStatOverflowsBehaviour()) return -1;
3399 }
3400 Double_t z= w;
3401 fTsumw += z;
3402 fTsumw2 += z*z;
3403 fTsumwx += z*x;
3404 fTsumwx2 += z*x*x;
3405 return bin;
3406}
3407
3408////////////////////////////////////////////////////////////////////////////////
3409/// Increment bin with namex with a weight w
3410///
3411/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3412/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3413///
3414/// If the weight is not equal to 1, the storage of the sum of squares of
3415/// weights is automatically triggered and the sum of the squares of weights is incremented
3416/// by \f$ w^2 \f$ in the bin corresponding to x.
3417///
3418/// The function returns the corresponding bin number which has its content
3419/// incremented by w.
3420
3421Int_t TH1::Fill(const char *namex, Double_t w)
3422{
3423 Int_t bin;
3424 fEntries++;
3425 bin =fXaxis.FindBin(namex);
3426 if (bin <0) return -1;
3427 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3428 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3429 AddBinContent(bin, w);
3430 if (bin == 0 || bin > fXaxis.GetNbins()) return -1;
3431 Double_t z= w;
3432 fTsumw += z;
3433 fTsumw2 += z*z;
3434 // this make sense if the histogram is not expanding (the x axis cannot be extended)
3435 if (!fXaxis.CanExtend() || !fXaxis.IsAlphanumeric()) {
3437 fTsumwx += z*x;
3438 fTsumwx2 += z*x*x;
3439 }
3440 return bin;
3441}
3442
3443////////////////////////////////////////////////////////////////////////////////
3444/// Fill this histogram with an array x and weights w.
3445///
3446/// \param[in] ntimes number of entries in arrays x and w (array size must be ntimes*stride)
3447/// \param[in] x array of values to be histogrammed
3448/// \param[in] w array of weighs
3449/// \param[in] stride step size through arrays x and w
3450///
3451/// If the weight is not equal to 1, the storage of the sum of squares of
3452/// weights is automatically triggered and the sum of the squares of weights is incremented
3453/// by \f$ w^2 \f$ in the bin corresponding to x.
3454/// if w is NULL each entry is assumed a weight=1
3455
3456void TH1::FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3457{
3458 //If a buffer is activated, fill buffer
3459 if (fBuffer) {
3460 ntimes *= stride;
3461 Int_t i = 0;
3462 for (i=0;i<ntimes;i+=stride) {
3463 if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty
3464 if (w) BufferFill(x[i],w[i]);
3465 else BufferFill(x[i], 1.);
3466 }
3467 // fill the remaining entries if the buffer has been deleted
3468 if (i < ntimes && fBuffer==0) {
3469 auto weights = w ? &w[i] : nullptr;
3470 DoFillN((ntimes-i)/stride,&x[i],weights,stride);
3471 }
3472 return;
3473 }
3474 // call internal method
3475 DoFillN(ntimes, x, w, stride);
3476}
3477
3478////////////////////////////////////////////////////////////////////////////////
3479/// Internal method to fill histogram content from a vector
3480/// called directly by TH1::BufferEmpty
3481
3482void TH1::DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3483{
3484 Int_t bin,i;
3485
3486 fEntries += ntimes;
3487 Double_t ww = 1;
3488 Int_t nbins = fXaxis.GetNbins();
3489 ntimes *= stride;
3490 for (i=0;i<ntimes;i+=stride) {
3491 bin =fXaxis.FindBin(x[i]);
3492 if (bin <0) continue;
3493 if (w) ww = w[i];
3494 if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3495 if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
3496 AddBinContent(bin, ww);
3497 if (bin == 0 || bin > nbins) {
3498 if (!GetStatOverflowsBehaviour()) continue;
3499 }
3500 Double_t z= ww;
3501 fTsumw += z;
3502 fTsumw2 += z*z;
3503 fTsumwx += z*x[i];
3504 fTsumwx2 += z*x[i]*x[i];
3505 }
3506}
3507
3508////////////////////////////////////////////////////////////////////////////////
3509/// Fill histogram following distribution in function fname.
3510///
3511/// @param fname : Function name used for filling the histogram
3512/// @param ntimes : number of times the histogram is filled
3513/// @param rng : (optional) Random number generator used to sample
3514///
3515///
3516/// The distribution contained in the function fname (TF1) is integrated
3517/// over the channel contents for the bin range of this histogram.
3518/// It is normalized to 1.
3519///
3520/// Getting one random number implies:
3521/// - Generating a random number between 0 and 1 (say r1)
3522/// - Look in which bin in the normalized integral r1 corresponds to
3523/// - Fill histogram channel
3524/// ntimes random numbers are generated
3525///
3526/// One can also call TF1::GetRandom to get a random variate from a function.
3527
3528void TH1::FillRandom(const char *fname, Int_t ntimes, TRandom * rng)
3529{
3530 Int_t bin, binx, ibin, loop;
3531 Double_t r1, x;
3532 // - Search for fname in the list of ROOT defined functions
3533 TF1 *f1 = (TF1*)gROOT->GetFunction(fname);
3534 if (!f1) { Error("FillRandom", "Unknown function: %s",fname); return; }
3535
3536 // - Allocate temporary space to store the integral and compute integral
3537
3538 TAxis * xAxis = &fXaxis;
3539
3540 // in case axis of histogram is not defined use the function axis
3541 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
3543 f1->GetRange(xmin,xmax);
3544 Info("FillRandom","Using function axis and range [%g,%g]",xmin, xmax);
3545 xAxis = f1->GetHistogram()->GetXaxis();
3546 }
3547
3548 Int_t first = xAxis->GetFirst();
3549 Int_t last = xAxis->GetLast();
3550 Int_t nbinsx = last-first+1;
3551
3552 Double_t *integral = new Double_t[nbinsx+1];
3553 integral[0] = 0;
3554 for (binx=1;binx<=nbinsx;binx++) {
3555 Double_t fint = f1->Integral(xAxis->GetBinLowEdge(binx+first-1),xAxis->GetBinUpEdge(binx+first-1), 0.);
3556 integral[binx] = integral[binx-1] + fint;
3557 }
3558
3559 // - Normalize integral to 1
3560 if (integral[nbinsx] == 0 ) {
3561 delete [] integral;
3562 Error("FillRandom", "Integral = zero"); return;
3563 }
3564 for (bin=1;bin<=nbinsx;bin++) integral[bin] /= integral[nbinsx];
3565
3566 // --------------Start main loop ntimes
3567 for (loop=0;loop<ntimes;loop++) {
3568 r1 = (rng) ? rng->Rndm() : gRandom->Rndm();
3569 ibin = TMath::BinarySearch(nbinsx,&integral[0],r1);
3570 //binx = 1 + ibin;
3571 //x = xAxis->GetBinCenter(binx); //this is not OK when SetBuffer is used
3572 x = xAxis->GetBinLowEdge(ibin+first)
3573 +xAxis->GetBinWidth(ibin+first)*(r1-integral[ibin])/(integral[ibin+1] - integral[ibin]);
3574 Fill(x);
3575 }
3576 delete [] integral;
3577}
3578
3579////////////////////////////////////////////////////////////////////////////////
3580/// Fill histogram following distribution in histogram h.
3581///
3582/// @param h : Histogram pointer used for sampling random number
3583/// @param ntimes : number of times the histogram is filled
3584/// @param rng : (optional) Random number generator used for sampling
3585///
3586/// The distribution contained in the histogram h (TH1) is integrated
3587/// over the channel contents for the bin range of this histogram.
3588/// It is normalized to 1.
3589///
3590/// Getting one random number implies:
3591/// - Generating a random number between 0 and 1 (say r1)
3592/// - Look in which bin in the normalized integral r1 corresponds to
3593/// - Fill histogram channel ntimes random numbers are generated
3594///
3595/// SPECIAL CASE when the target histogram has the same binning as the source.
3596/// in this case we simply use a poisson distribution where
3597/// the mean value per bin = bincontent/integral.
3598
3599void TH1::FillRandom(TH1 *h, Int_t ntimes, TRandom * rng)
3600{
3601 if (!h) { Error("FillRandom", "Null histogram"); return; }
3602 if (fDimension != h->GetDimension()) {
3603 Error("FillRandom", "Histograms with different dimensions"); return;
3604 }
3605 if (std::isnan(h->ComputeIntegral(true))) {
3606 Error("FillRandom", "Histograms contains negative bins, does not represent probabilities");
3607 return;
3608 }
3609
3610 //in case the target histogram has the same binning and ntimes much greater
3611 //than the number of bins we can use a fast method
3613 Int_t last = fXaxis.GetLast();
3614 Int_t nbins = last-first+1;
3615 if (ntimes > 10*nbins) {
3616 try {
3617 CheckConsistency(this,h);
3618 Double_t sumw = h->Integral(first,last);
3619 if (sumw == 0) return;
3620 Double_t sumgen = 0;
3621 for (Int_t bin=first;bin<=last;bin++) {
3622 Double_t mean = h->RetrieveBinContent(bin)*ntimes/sumw;
3623 Double_t cont = (rng) ? rng->Poisson(mean) : gRandom->Poisson(mean);
3624 sumgen += cont;
3625 AddBinContent(bin,cont);
3626 if (fSumw2.fN) fSumw2.fArray[bin] += cont;
3627 }
3628
3629 // fix for the fluctuations in the total number n
3630 // since we use Poisson instead of multinomial
3631 // add a correction to have ntimes as generated entries
3632 Int_t i;
3633 if (sumgen < ntimes) {
3634 // add missing entries
3635 for (i = Int_t(sumgen+0.5); i < ntimes; ++i)
3636 {
3637 Double_t x = h->GetRandom();
3638 Fill(x);
3639 }
3640 }
3641 else if (sumgen > ntimes) {
3642 // remove extra entries
3643 i = Int_t(sumgen+0.5);
3644 while( i > ntimes) {
3645 Double_t x = h->GetRandom(rng);
3646 Int_t ibin = fXaxis.FindBin(x);
3648 // skip in case bin is empty
3649 if (y > 0) {
3650 SetBinContent(ibin, y-1.);
3651 i--;
3652 }
3653 }
3654 }
3655
3656 ResetStats();
3657 return;
3658 }
3659 catch(std::exception&) {} // do nothing
3660 }
3661 // case of different axis and not too large ntimes
3662
3663 if (h->ComputeIntegral() ==0) return;
3664 Int_t loop;
3665 Double_t x;
3666 for (loop=0;loop<ntimes;loop++) {
3667 x = h->GetRandom();
3668 Fill(x);
3669 }
3670}
3671
3672////////////////////////////////////////////////////////////////////////////////
3673/// Return Global bin number corresponding to x,y,z
3674///
3675/// 2-D and 3-D histograms are represented with a one dimensional
3676/// structure. This has the advantage that all existing functions, such as
3677/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
3678/// This function tries to extend the axis if the given point belongs to an
3679/// under-/overflow bin AND if CanExtendAllAxes() is true.
3680///
3681/// See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin
3682
3684{
3685 if (GetDimension() < 2) {
3686 return fXaxis.FindBin(x);
3687 }
3688 if (GetDimension() < 3) {
3689 Int_t nx = fXaxis.GetNbins()+2;
3690 Int_t binx = fXaxis.FindBin(x);
3691 Int_t biny = fYaxis.FindBin(y);
3692 return binx + nx*biny;
3693 }
3694 if (GetDimension() < 4) {
3695 Int_t nx = fXaxis.GetNbins()+2;
3696 Int_t ny = fYaxis.GetNbins()+2;
3697 Int_t binx = fXaxis.FindBin(x);
3698 Int_t biny = fYaxis.FindBin(y);
3699 Int_t binz = fZaxis.FindBin(z);
3700 return binx + nx*(biny +ny*binz);
3701 }
3702 return -1;
3703}
3704
3705////////////////////////////////////////////////////////////////////////////////
3706/// Return Global bin number corresponding to x,y,z.
3707///
3708/// 2-D and 3-D histograms are represented with a one dimensional
3709/// structure. This has the advantage that all existing functions, such as
3710/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
3711/// This function DOES NOT try to extend the axis if the given point belongs
3712/// to an under-/overflow bin.
3713///
3714/// See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin
3715
3717{
3718 if (GetDimension() < 2) {
3719 return fXaxis.FindFixBin(x);
3720 }
3721 if (GetDimension() < 3) {
3722 Int_t nx = fXaxis.GetNbins()+2;
3723 Int_t binx = fXaxis.FindFixBin(x);
3724 Int_t biny = fYaxis.FindFixBin(y);
3725 return binx + nx*biny;
3726 }
3727 if (GetDimension() < 4) {
3728 Int_t nx = fXaxis.GetNbins()+2;
3729 Int_t ny = fYaxis.GetNbins()+2;
3730 Int_t binx = fXaxis.FindFixBin(x);
3731 Int_t biny = fYaxis.FindFixBin(y);
3732 Int_t binz = fZaxis.FindFixBin(z);
3733 return binx + nx*(biny +ny*binz);
3734 }
3735 return -1;
3736}
3737
3738////////////////////////////////////////////////////////////////////////////////
3739/// Find first bin with content > threshold for axis (1=x, 2=y, 3=z)
3740/// if no bins with content > threshold is found the function returns -1.
3741/// The search will occur between the specified first and last bin. Specifying
3742/// the value of the last bin to search to less than zero will search until the
3743/// last defined bin.
3744
3745Int_t TH1::FindFirstBinAbove(Double_t threshold, Int_t axis, Int_t firstBin, Int_t lastBin) const
3746{
3747 if (fBuffer) ((TH1*)this)->BufferEmpty();
3748
3749 if (axis < 1 || (axis > 1 && GetDimension() == 1 ) ||
3750 ( axis > 2 && GetDimension() == 2 ) || ( axis > 3 && GetDimension() > 3 ) ) {
3751 Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
3752 axis = 1;
3753 }
3754 if (firstBin < 1) {
3755 firstBin = 1;
3756 }
3757 Int_t nbinsx = fXaxis.GetNbins();
3758 Int_t nbinsy = (GetDimension() > 1 ) ? fYaxis.GetNbins() : 1;
3759 Int_t nbinsz = (GetDimension() > 2 ) ? fZaxis.GetNbins() : 1;
3760
3761 if (axis == 1) {
3762 if (lastBin < 0 || lastBin > fXaxis.GetNbins()) {
3763 lastBin = fXaxis.GetNbins();
3764 }
3765 for (Int_t binx = firstBin; binx <= lastBin; binx++) {
3766 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3767 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3768 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return binx;
3769 }
3770 }
3771 }
3772 }
3773 else if (axis == 2) {
3774 if (lastBin < 0 || lastBin > fYaxis.GetNbins()) {
3775 lastBin = fYaxis.GetNbins();
3776 }
3777 for (Int_t biny = firstBin; biny <= lastBin; biny++) {
3778 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3779 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3780 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return biny;
3781 }
3782 }
3783 }
3784 }
3785 else if (axis == 3) {
3786 if (lastBin < 0 || lastBin > fZaxis.GetNbins()) {
3787 lastBin = fZaxis.GetNbins();
3788 }
3789 for (Int_t binz = firstBin; binz <= lastBin; binz++) {
3790 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3791 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3792 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return binz;
3793 }
3794 }
3795 }
3796 }
3797
3798 return -1;
3799}
3800
3801////////////////////////////////////////////////////////////////////////////////
3802/// Find last bin with content > threshold for axis (1=x, 2=y, 3=z)
3803/// if no bins with content > threshold is found the function returns -1.
3804/// The search will occur between the specified first and last bin. Specifying
3805/// the value of the last bin to search to less than zero will search until the
3806/// last defined bin.
3807
3808Int_t TH1::FindLastBinAbove(Double_t threshold, Int_t axis, Int_t firstBin, Int_t lastBin) const
3809{
3810 if (fBuffer) ((TH1*)this)->BufferEmpty();
3811
3812
3813 if (axis < 1 || ( axis > 1 && GetDimension() == 1 ) ||
3814 ( axis > 2 && GetDimension() == 2 ) || ( axis > 3 && GetDimension() > 3) ) {
3815 Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
3816 axis = 1;
3817 }
3818 if (firstBin < 1) {
3819 firstBin = 1;
3820 }
3821 Int_t nbinsx = fXaxis.GetNbins();
3822 Int_t nbinsy = (GetDimension() > 1 ) ? fYaxis.GetNbins() : 1;
3823 Int_t nbinsz = (GetDimension() > 2 ) ? fZaxis.GetNbins() : 1;
3824
3825 if (axis == 1) {
3826 if (lastBin < 0 || lastBin > fXaxis.GetNbins()) {
3827 lastBin = fXaxis.GetNbins();
3828 }
3829 for (Int_t binx = lastBin; binx >= firstBin; binx--) {
3830 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3831 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3832 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return binx;
3833 }
3834 }
3835 }
3836 }
3837 else if (axis == 2) {
3838 if (lastBin < 0 || lastBin > fYaxis.GetNbins()) {
3839 lastBin = fYaxis.GetNbins();
3840 }
3841 for (Int_t biny = lastBin; biny >= firstBin; biny--) {
3842 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3843 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3844 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return biny;
3845 }
3846 }
3847 }
3848 }
3849 else if (axis == 3) {
3850 if (lastBin < 0 || lastBin > fZaxis.GetNbins()) {
3851 lastBin = fZaxis.GetNbins();
3852 }
3853 for (Int_t binz = lastBin; binz >= firstBin; binz--) {
3854 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3855 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3856 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return binz;
3857 }
3858 }
3859 }
3860 }
3861
3862 return -1;
3863}
3864
3865////////////////////////////////////////////////////////////////////////////////
3866/// Search object named name in the list of functions.
3867
3868TObject *TH1::FindObject(const char *name) const
3869{
3870 if (fFunctions) return fFunctions->FindObject(name);
3871 return 0;
3872}
3873
3874////////////////////////////////////////////////////////////////////////////////
3875/// Search object obj in the list of functions.
3876
3877TObject *TH1::FindObject(const TObject *obj) const
3878{
3879 if (fFunctions) return fFunctions->FindObject(obj);
3880 return 0;
3881}
3882
3883////////////////////////////////////////////////////////////////////////////////
3884/// Fit histogram with function fname.
3885///
3886/// fname is the name of an already predefined function created by TF1 or TF2
3887/// Predefined functions such as gaus, expo and poln are automatically
3888/// created by ROOT.
3889/// fname can also be a formula, accepted by the linear fitter (linear parts divided
3890/// by "++" sign), for example "x++sin(x)" for fitting "[0]*x+[1]*sin(x)"
3891///
3892/// This function finds a pointer to the TF1 object with name fname
3893/// and calls TH1::Fit(TF1 *f1,...)
3894
3895TFitResultPtr TH1::Fit(const char *fname ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax)
3896{
3897 char *linear;
3898 linear= (char*)strstr(fname, "++");
3899 Int_t ndim=GetDimension();
3900 if (linear){
3901 if (ndim<2){
3902 TF1 f1(fname, fname, xxmin, xxmax);
3903 return Fit(&f1,option,goption,xxmin,xxmax);
3904 }
3905 else if (ndim<3){
3906 TF2 f2(fname, fname);
3907 return Fit(&f2,option,goption,xxmin,xxmax);
3908 }
3909 else{
3910 TF3 f3(fname, fname);
3911 return Fit(&f3,option,goption,xxmin,xxmax);
3912 }
3913 }
3914 else{
3915 TF1 * f1 = (TF1*)gROOT->GetFunction(fname);
3916 if (!f1) { Printf("Unknown function: %s",fname); return -1; }
3917 return Fit(f1,option,goption,xxmin,xxmax);
3918 }
3919}
3920
3921////////////////////////////////////////////////////////////////////////////////
3922/// Fit histogram with function f1.
3923///
3924/// \param[in] option fit options is given in parameter option.
3925/// - "W" Ignore the bin uncertainties when fitting using the default least square (chi2) method but skip empty bins
3926/// - "WW" Ignore the bin uncertainties when fitting using the default least square (chi2) method and include also the empty bins
3927/// - "I" Use integral of function in bin, normalized by the bin volume,
3928/// instead of value at bin center
3929/// - "L" Use Loglikelihood method (default is chisquare method)
3930/// - "WL" Use Loglikelihood method and bin contents are not integer,
3931/// i.e. histogram is weighted (must have Sumw2() set)
3932/// -"MULTI" Use Loglikelihood method based on multi-nomial distribution.
3933/// In this case function must be normalized and one fits only the function shape (a not extended binned
3934/// likelihood fit)
3935/// - "P" Use Pearson chi2 (using expected errors instead of observed errors)
3936/// - "U" Use a User specified fitting algorithm (via SetFCN)
3937/// - "Q" Quiet mode (minimum printing)
3938/// - "V" Verbose mode (default is between Q and V)
3939/// - "E" Perform better Errors estimation using Minos technique
3940/// - "B" User defined parameter settings are used for predefined functions
3941/// like "gaus", "expo", "poln", "landau".
3942/// Use this option when you want to fix one or more parameters for these functions.
3943/// - "M" More. Improve fit results.
3944/// It uses the IMPROVE command of TMinuit (see TMinuit::mnimpr).
3945/// This algorithm attempts to improve the found local minimum by searching for a
3946/// better one.
3947/// - "R" Use the Range specified in the function range
3948/// - "N" Do not store the graphics function, do not draw
3949/// - "0" Do not plot the result of the fit. By default the fitted function
3950/// is drawn unless the option"N" above is specified.
3951/// - "+" Add this new fitted function to the list of fitted functions
3952/// (by default, any previous function is deleted)
3953/// - "C" In case of linear fitting, don't calculate the chisquare
3954/// (saves time)
3955/// - "F" If fitting a polN, switch to minuit fitter
3956/// - "S" The result of the fit is returned in the TFitResultPtr
3957/// (see below Access to the Fit Result)
3958/// \param[in] goption specify a list of graphics options. See TH1::Draw for a complete list of these options.
3959/// \param[in] xxmin range
3960/// \param[in] xxmax range
3961///
3962/// In order to use the Range option, one must first create a function
3963/// with the expression to be fitted. For example, if your histogram
3964/// has a defined range between -4 and 4 and you want to fit a gaussian
3965/// only in the interval 1 to 3, you can do:
3966///
3967/// ~~~ {.cpp}
3968/// TF1 *f1 = new TF1("f1", "gaus", 1, 3);
3969/// histo->Fit("f1", "R");
3970/// ~~~
3971///
3972/// ## Setting initial conditions
3973/// Parameters must be initialized before invoking the Fit function.
3974/// The setting of the parameter initial values is automatic for the
3975/// predefined functions : poln, expo, gaus, landau. One can however disable
3976/// this automatic computation by specifying the option "B".
3977/// Note that if a predefined function is defined with an argument,
3978/// eg, gaus(0), expo(1), you must specify the initial values for
3979/// the parameters.
3980/// You can specify boundary limits for some or all parameters via
3981///
3982/// ~~~ {.cpp}
3983/// f1->SetParLimits(p_number, parmin, parmax);
3984/// ~~~
3985///
3986/// if parmin>=parmax, the parameter is fixed
3987/// Note that you are not forced to fix the limits for all parameters.
3988/// For example, if you fit a function with 6 parameters, you can do:
3989///
3990/// ~~~ {.cpp}
3991/// func->SetParameters(0, 3.1, 1.e-6, -8, 0, 100);
3992/// func->SetParLimits(3, -10, -4);
3993/// func->FixParameter(4, 0);
3994/// func->SetParLimits(5, 1, 1);
3995/// ~~~
3996///
3997/// With this setup, parameters 0->2 can vary freely
3998/// Parameter 3 has boundaries [-10,-4] with initial value -8
3999/// Parameter 4 is fixed to 0
4000/// Parameter 5 is fixed to 100.
4001/// When the lower limit and upper limit are equal, the parameter is fixed.
4002/// However to fix a parameter to 0, one must call the FixParameter function.
4003///
4004///
4005/// #### Changing the fitting objective function
4006///
4007/// By default a chi square function is used for fitting. When option "L" (or "LL") is used
4008/// a Poisson likelihood function (see note below) is used.
4009/// Using option "MULTI" a multinomial likelihood fit is used. In this case the function normalization is not fitted
4010/// but only the function shape. Therefore the provided function must be normalized.
4011/// The functions are defined in the header Fit/Chi2Func.h or Fit/PoissonLikelihoodFCN and they
4012/// are implemented using the routines FitUtil::EvaluateChi2 or FitUtil::EvaluatePoissonLogL in
4013/// the file math/mathcore/src/FitUtil.cxx.
4014/// To specify a User defined fitting function, specify option "U" and
4015/// call the following functions:
4016///
4017/// ~~~ {.cpp}
4018/// TVirtualFitter::Fitter(myhist)->SetFCN(MyFittingFunction)
4019/// ~~~
4020///
4021/// where MyFittingFunction is of type:
4022///
4023/// ~~~ {.cpp}
4024/// extern void MyFittingFunction(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);
4025/// ~~~
4026///
4027/// #### Chi2 Fits
4028///
4029/// By default a chi2 (least-square) fit is performed on the histogram. The so-called modified least-square method
4030/// is used where the residual for each bin is computed using as error the observed value (the bin error)
4031///
4032/// \f[
4033/// Chi2 = \sum{ \left(\frac{y(i) - f(x(i) | p )}{e(i)} \right)^2 }
4034/// \f]
4035///
4036/// where y(i) is the bin content for each bin i, x(i) is the bin center and e(i) is the bin error (sqrt(y(i) for
4037/// an un-weighted histogram. Bins with zero errors are excluded from the fit. See also later the note on the treatment
4038/// of empty bins. When using option "I" the residual is computed not using the function value at the bin center, f
4039/// (x(i) | p), but the integral of the function in the bin, Integral{ f(x|p)dx } divided by the bin volume
4040///
4041/// #### Likelihood Fits
4042///
4043/// When using option "L" a likelihood fit is used instead of the default chi2 square fit.
4044/// The likelihood is built assuming a Poisson probability density function for each bin.
4045/// The negative log-likelihood to be minimized is
4046///
4047/// \f[
4048/// NLL = \sum{ log Poisson ( y(i) | f(x(i) | p ) ) }
4049/// \f]
4050///
4051/// The exact likelihood used is the Poisson likelihood described in this paper:
4052/// S. Baker and R. D. Cousins, “Clarification of the use of chi-square and likelihood functions in fits to histograms,”
4053/// Nucl. Instrum. Meth. 221 (1984) 437.
4054///
4055/// This method can then be used only when the bin content represents counts (i.e. errors are sqrt(N) ).
4056/// The likelihood method has the advantage of treating correctly bins with low statistics. In case of high
4057/// statistics/bin the distribution of the bin content becomes a normal distribution and the likelihood and chi2 fit
4058/// give the same result.
4059///
4060/// The likelihood method, although a bit slower, it is therefore the recommended method in case of low
4061/// bin statistics, where the chi2 method may give incorrect results, in particular when there are
4062/// several empty bins (see also below).
4063/// In case of a weighted histogram, it is possible to perform a likelihood fit by using the
4064/// option "WL". Note a weighted histogram is an histogram which has been filled with weights and it
4065/// contains the sum of the weight square ( TH1::Sumw2() has been called). The bin error for a weighted
4066/// histogram is the square root of the sum of the weight square.
4067///
4068/// #### Treatment of Empty Bins
4069///
4070/// Empty bins, which have the content equal to zero AND error equal to zero,
4071/// are excluded by default from the chisquare fit, but they are considered in the likelihood fit.
4072/// since they affect the likelihood if the function value in these bins is not negligible.
4073/// When using option "WW" these bins will be considered in the chi2 fit with an error of 1.
4074/// Note that if the histogram is having bins with zero content and non zero-errors they are considered as
4075/// any other bins in the fit. Instead bins with zero error and non-zero content are excluded in the chi2 fit.
4076/// A likelihood fit should also not be performed on such an histogram, since we are assuming a wrong pdf for each bin.
4077/// In general, one should not fit an histogram with non-empty bins and zero errors, apart if all the bins have zero
4078/// errors. In this case one could use the option "w", which gives a weight=1 for each bin (unweighted least-square
4079/// fit).
4080/// Note that in case of histogram with no errors (chi2 fit with option W or W1) the resulting fitted parameter errors
4081/// are corrected by the obtained chi2 value using this expression: errorp *= sqrt(chisquare/(ndf-1))
4082///
4083/// #### Fitting a histogram of dimension N with a function of dimension N-1
4084///
4085/// It is possible to fit a TH2 with a TF1 or a TH3 with a TF2.
4086/// In this case the option "Integral" is not allowed and each cell has
4087/// equal weight. Also in this case the obtained parameter error are corrected as in the case when the
4088/// option "W" is used (see above)
4089///
4090/// #### Associated functions
4091///
4092/// One or more object (typically a TF1*) can be added to the list
4093/// of functions (fFunctions) associated to each histogram.
4094/// When TH1::Fit is invoked, the fitted function is added to this list.
4095/// Given an histogram h, one can retrieve an associated function
4096/// with:
4097///
4098/// ~~~ {.cpp}
4099/// TF1 *myfunc = h->GetFunction("myfunc");
4100/// ~~~
4101///
4102/// #### Access to the fit result
4103///
4104/// The function returns a TFitResultPtr which can hold a pointer to a TFitResult object.
4105/// By default the TFitResultPtr contains only the status of the fit which is return by an
4106/// automatic conversion of the TFitResultPtr to an integer. One can write in this case directly:
4107///
4108/// ~~~ {.cpp}
4109/// Int_t fitStatus = h->Fit(myFunc)
4110/// ~~~
4111///
4112/// If the option "S" is instead used, TFitResultPtr contains the TFitResult and behaves as a smart
4113/// pointer to it. For example one can do:
4114///
4115/// ~~~ {.cpp}
4116/// TFitResultPtr r = h->Fit(myFunc,"S");
4117/// TMatrixDSym cov = r->GetCovarianceMatrix(); // to access the covariance matrix
4118/// Double_t chi2 = r->Chi2(); // to retrieve the fit chi2
4119/// Double_t par0 = r->Parameter(0); // retrieve the value for the parameter 0
4120/// Double_t err0 = r->ParError(0); // retrieve the error for the parameter 0
4121/// r->Print("V"); // print full information of fit including covariance matrix
4122/// r->Write(); // store the result in a file
4123/// ~~~
4124///
4125/// The fit parameters, error and chi2 (but not covariance matrix) can be retrieved also
4126/// from the fitted function.
4127/// If the histogram is made persistent, the list of
4128/// associated functions is also persistent. Given a pointer (see above)
4129/// to an associated function myfunc, one can retrieve the function/fit
4130/// parameters with calls such as:
4131///
4132/// ~~~ {.cpp}
4133/// Double_t chi2 = myfunc->GetChisquare();
4134/// Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter
4135/// Double_t err0 = myfunc->GetParError(0); //error on first parameter
4136/// ~~~
4137///
4138/// #### Access to the fit status
4139///
4140/// The status of the fit can be obtained converting the TFitResultPtr to an integer
4141/// independently if the fit option "S" is used or not:
4142///
4143/// ~~~ {.cpp}
4144/// TFitResultPtr r = h->Fit(myFunc,opt);
4145/// Int_t fitStatus = r;
4146/// ~~~
4147///
4148/// The fitStatus is 0 if the fit is OK (i.e no error occurred).
4149/// The value of the fit status code is negative in case of an error not connected with the
4150/// minimization procedure, for example when a wrong function is used.
4151/// Otherwise the return value is the one returned from the minimization procedure.
4152/// When TMinuit (default case) or Minuit2 are used as minimizer the status returned is :
4153/// `fitStatus = migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult`.
4154/// TMinuit will return 0 (for migrad, minos, hesse or improve) in case of success and 4 in
4155/// case of error (see the documentation of TMinuit::mnexcm). So for example, for an error
4156/// only in Minos but not in Migrad a fitStatus of 40 will be returned.
4157/// Minuit2 will return also 0 in case of success and different values in migrad minos or
4158/// hesse depending on the error. See in this case the documentation of
4159/// Minuit2Minimizer::Minimize for the migradResult, Minuit2Minimizer::GetMinosError for the
4160/// minosResult and Minuit2Minimizer::Hesse for the hesseResult.
4161/// If other minimizers are used see their specific documentation for the status code returned.
4162/// For example in the case of Fumili, for the status returned see TFumili::Minimize.
4163///
4164/// #### Excluding points
4165///
4166/// Use TF1::RejectPoint inside your fitting function to exclude points
4167/// within a certain range from the fit. Example:
4168///
4169/// ~~~ {.cpp}
4170/// Double_t fline(Double_t *x, Double_t *par)
4171/// {
4172/// if (x[0] > 2.5 && x[0] < 3.5) {
4173/// TF1::RejectPoint();
4174/// return 0;
4175/// }
4176/// return par[0] + par[1]*x[0];
4177/// }
4178///
4179/// void exclude() {
4180/// TF1 *f1 = new TF1("f1", "[0] +[1]*x +gaus(2)", 0, 5);
4181/// f1->SetParameters(6, -1,5, 3, 0.2);
4182/// TH1F *h = new TH1F("h", "background + signal", 100, 0, 5);
4183/// h->FillRandom("f1", 2000);
4184/// TF1 *fline = new TF1("fline", fline, 0, 5, 2);
4185/// fline->SetParameters(2, -1);
4186/// h->Fit("fline", "l");
4187/// }
4188/// ~~~
4189///
4190/// #### Warning when using the option "0"
4191///
4192/// When selecting the option "0", the fitted function is added to
4193/// the list of functions of the histogram, but it is not drawn.
4194/// You can undo what you disabled in the following way:
4195///
4196/// ~~~ {.cpp}
4197/// h.Fit("myFunction", "0"); // fit, store function but do not draw
4198/// h.Draw(); function is not drawn
4199/// const Int_t kNotDraw = 1<<9;
4200/// h.GetFunction("myFunction")->ResetBit(kNotDraw);
4201/// h.Draw(); // function is visible again
4202/// ~~~
4203///
4204/// #### Access to the Minimizer information during fitting
4205///
4206/// This function calls, the ROOT::Fit::FitObject function implemented in HFitImpl.cxx
4207/// which uses the ROOT::Fit::Fitter class. The Fitter class creates the objective function
4208/// (e.g. chi2 or likelihood) and uses an implementation of the Minimizer interface for minimizing
4209/// the function.
4210/// The default minimizer is Minuit (class TMinuitMinimizer which calls TMinuit).
4211/// The default can be set in the resource file in etc/system.rootrc. For example
4212///
4213/// ~~~ {.cpp}
4214/// Root.Fitter: Minuit2
4215/// ~~~
4216///
4217/// A different fitter can also be set via ROOT::Math::MinimizerOptions::SetDefaultMinimizer
4218/// (or TVirtualFitter::SetDefaultFitter).
4219/// For example ROOT::Math::MinimizerOptions::SetDefaultMinimizer("GSLMultiMin","BFGS");
4220/// will set the usage of the BFGS algorithm of the GSL multi-dimensional minimization
4221/// (implemented in libMathMore). ROOT::Math::MinimizerOptions can be used also to set other
4222/// default options, like maximum number of function calls, minimization tolerance or print
4223/// level. See the documentation of this class.
4224///
4225/// For fitting linear functions (containing the "++" sign" and polN functions,
4226/// the linear fitter is automatically initialized.
4227
4228TFitResultPtr TH1::Fit(TF1 *f1 ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax)
4229{
4230 // implementation of Fit method is in file hist/src/HFitImpl.cxx
4231 Foption_t fitOption;
4233
4234 // create range and minimizer options with default values
4235 ROOT::Fit::DataRange range(xxmin,xxmax);
4237
4238 // need to empty the buffer before
4239 // (t.b.d. do a ML unbinned fit with buffer data)
4240 if (fBuffer) BufferEmpty();
4241
4242 return ROOT::Fit::FitObject(this, f1 , fitOption , minOption, goption, range);
4243}
4244
4245////////////////////////////////////////////////////////////////////////////////
4246/// Display a panel with all histogram fit options.
4247///
4248/// See class TFitPanel for example
4249
4250void TH1::FitPanel()
4251{
4252 if (!gPad)
4253 gROOT->MakeDefCanvas();
4254
4255 if (!gPad) {
4256 Error("FitPanel", "Unable to create a default canvas");
4257 return;
4258 }
4259
4260
4261 // use plugin manager to create instance of TFitEditor
4262 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor");
4263 if (handler && handler->LoadPlugin() != -1) {
4264 if (handler->ExecPlugin(2, gPad, this) == 0)
4265 Error("FitPanel", "Unable to create the FitPanel");
4266 }
4267 else
4268 Error("FitPanel", "Unable to find the FitPanel plug-in");
4269}
4270
4271////////////////////////////////////////////////////////////////////////////////
4272/// Return an histogram containing the asymmetry of this histogram with h2,
4273/// where the asymmetry is defined as:
4274///
4275/// ~~~ {.cpp}
4276/// Asymmetry = (h1 - h2)/(h1 + h2) where h1 = this
4277/// ~~~
4278///
4279/// works for 1D, 2D, etc. histograms
4280/// c2 is an optional argument that gives a relative weight between the two
4281/// histograms, and dc2 is the error on this weight. This is useful, for example,
4282/// when forming an asymmetry between two histograms from 2 different data sets that
4283/// need to be normalized to each other in some way. The function calculates
4284/// the errors assuming Poisson statistics on h1 and h2 (that is, dh = sqrt(h)).
4285///
4286/// example: assuming 'h1' and 'h2' are already filled
4287///
4288/// ~~~ {.cpp}
4289/// h3 = h1->GetAsymmetry(h2)
4290/// ~~~
4291///
4292/// then 'h3' is created and filled with the asymmetry between 'h1' and 'h2';
4293/// h1 and h2 are left intact.
4294///
4295/// Note that it is the user's responsibility to manage the created histogram.
4296/// The name of the returned histogram will be `Asymmetry_nameOfh1-nameOfh2`
4297///
4298/// code proposed by Jason Seely (seely@mit.edu) and adapted by R.Brun
4299///
4300/// clone the histograms so top and bottom will have the
4301/// correct dimensions:
4302/// Sumw2 just makes sure the errors will be computed properly
4303/// when we form sums and ratios below.
4304
4306{
4307 TH1 *h1 = this;
4308 TString name = TString::Format("Asymmetry_%s-%s",h1->GetName(),h2->GetName() );
4309 TH1 *asym = (TH1*)Clone(name);
4310
4311 // set also the title
4312 TString title = TString::Format("(%s - %s)/(%s+%s)",h1->GetName(),h2->GetName(),h1->GetName(),h2->GetName() );
4313 asym->SetTitle(title);
4314
4315 asym->Sumw2();
4316 Bool_t addStatus = TH1::AddDirectoryStatus();
4318 TH1 *top = (TH1*)asym->Clone();
4319 TH1 *bottom = (TH1*)asym->Clone();
4320 TH1::AddDirectory(addStatus);
4321
4322 // form the top and bottom of the asymmetry, and then divide:
4323 top->Add(h1,h2,1,-c2);
4324 bottom->Add(h1,h2,1,c2);
4325 asym->Divide(top,bottom);
4326
4327 Int_t xmax = asym->GetNbinsX();
4328 Int_t ymax = asym->GetNbinsY();
4329 Int_t zmax = asym->GetNbinsZ();
4330
4331 if (h1->fBuffer) h1->BufferEmpty(1);
4332 if (h2->fBuffer) h2->BufferEmpty(1);
4333 if (bottom->fBuffer) bottom->BufferEmpty(1);
4334
4335 // now loop over bins to calculate the correct errors
4336 // the reason this error calculation looks complex is because of c2
4337 for(Int_t i=1; i<= xmax; i++){
4338 for(Int_t j=1; j<= ymax; j++){
4339 for(Int_t k=1; k<= zmax; k++){
4340 Int_t bin = GetBin(i, j, k);
4341 // here some bin contents are written into variables to make the error
4342 // calculation a little more legible:
4344 Double_t b = h2->RetrieveBinContent(bin);
4345 Double_t bot = bottom->RetrieveBinContent(bin);
4346
4347 // make sure there are some events, if not, then the errors are set = 0
4348 // automatically.
4349 //if(bot < 1){} was changed to the next line from recommendation of Jason Seely (28 Nov 2005)
4350 if(bot < 1e-6){}
4351 else{
4352 // computation of errors by Christos Leonidopoulos
4353 Double_t dasq = h1->GetBinErrorSqUnchecked(bin);
4354 Double_t dbsq = h2->GetBinErrorSqUnchecked(bin);
4355 Double_t error = 2*TMath::Sqrt(a*a*c2*c2*dbsq + c2*c2*b*b*dasq+a*a*b*b*dc2*dc2)/(bot*bot);
4356 asym->SetBinError(i,j,k,error);
4357 }
4358 }
4359 }
4360 }
4361 delete top;
4362 delete bottom;
4363
4364 return asym;
4365}
4366
4367////////////////////////////////////////////////////////////////////////////////
4368/// Static function
4369/// return the default buffer size for automatic histograms
4370/// the parameter fgBufferSize may be changed via SetDefaultBufferSize
4371
4373{
4374 return fgBufferSize;
4375}
4376
4377////////////////////////////////////////////////////////////////////////////////
4378/// Return kTRUE if TH1::Sumw2 must be called when creating new histograms.
4379/// see TH1::SetDefaultSumw2.
4380
4382{
4383 return fgDefaultSumw2;
4384}
4385
4386////////////////////////////////////////////////////////////////////////////////
4387/// Return the current number of entries.
4388
4390{
4391 if (fBuffer) {
4392 Int_t nentries = (Int_t) fBuffer[0];
4393 if (nentries > 0) return nentries;
4394 }
4395
4396 return fEntries;
4397}
4398
4399////////////////////////////////////////////////////////////////////////////////
4400/// Number of effective entries of the histogram.
4401///
4402/// \f[
4403/// neff = \frac{(\sum Weights )^2}{(\sum Weight^2 )}
4404/// \f]
4405///
4406/// In case of an unweighted histogram this number is equivalent to the
4407/// number of entries of the histogram.
4408/// For a weighted histogram, this number corresponds to the hypothetical number of unweighted entries
4409/// a histogram would need to have the same statistical power as this weighted histogram.
4410/// Note: The underflow/overflow are included if one has set the TH1::StatOverFlows flag
4411/// and if the statistics has been computed at filling time.
4412/// If a range is set in the histogram the number is computed from the given range.
4413
4415{
4416 Stat_t s[kNstat];
4417 this->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
4418 return (s[1] ? s[0]*s[0]/s[1] : TMath::Abs(s[0]) );
4419}
4420
4421////////////////////////////////////////////////////////////////////////////////
4422/// Set highlight (enable/disable) mode for the histogram
4423/// by default highlight mode is disable
4424
4425void TH1::SetHighlight(Bool_t set)
4426{
4427 if (IsHighlight() == set) return;
4428 if (fDimension > 2) {
4429 Info("SetHighlight", "Supported only 1-D or 2-D histograms");
4430 return;
4431 }
4432
4433 if (!fPainter) {
4434 Info("SetHighlight", "Need to draw histogram first");
4435 return;
4436 }
4437 SetBit(kIsHighlight, set);
4439}
4440
4441////////////////////////////////////////////////////////////////////////////////
4442/// Redefines TObject::GetObjectInfo.
4443/// Displays the histogram info (bin number, contents, integral up to bin
4444/// corresponding to cursor position px,py
4445
4446char *TH1::GetObjectInfo(Int_t px, Int_t py) const
4447{
4448 return ((TH1*)this)->GetPainter()->GetObjectInfo(px,py);
4449}
4450
4451////////////////////////////////////////////////////////////////////////////////
4452/// Return pointer to painter.
4453/// If painter does not exist, it is created
4454
4456{
4457 if (!fPainter) {
4458 TString opt = option;
4459 opt.ToLower();
4460 if (opt.Contains("gl") || gStyle->GetCanvasPreferGL()) {
4461 //try to create TGLHistPainter
4462 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TGLHistPainter");
4463
4464 if (handler && handler->LoadPlugin() != -1)
4465 fPainter = reinterpret_cast<TVirtualHistPainter *>(handler->ExecPlugin(1, this));
4466 }
4467 }
4468
4470
4471 return fPainter;
4472}
4473
4474////////////////////////////////////////////////////////////////////////////////
4475/// Compute Quantiles for this histogram
4476/// Quantile x_q of a probability distribution Function F is defined as
4477///
4478/// ~~~ {.cpp}
4479/// F(x_q) = q with 0 <= q <= 1.
4480/// ~~~
4481///
4482/// For instance the median x_0.5 of a distribution is defined as that value
4483/// of the random variable for which the distribution function equals 0.5:
4484///
4485/// ~~~ {.cpp}
4486/// F(x_0.5) = Probability(x < x_0.5) = 0.5
4487/// ~~~
4488///
4489/// code from Eddy Offermann, Renaissance
4490///
4491/// \param[in] nprobSum maximum size of array q and size of array probSum (if given)
4492/// \param[in] probSum array of positions where quantiles will be computed.
4493/// - if probSum is null, probSum will be computed internally and will
4494/// have a size = number of bins + 1 in h. it will correspond to the
4495/// quantiles calculated at the lowest edge of the histogram (quantile=0) and
4496/// all the upper edges of the bins.
4497/// - if probSum is not null, it is assumed to contain at least nprobSum values.
4498/// \param[out] q array q filled with nq quantiles
4499/// \return value nq (<=nprobSum) with the number of quantiles computed
4500///
4501/// Note that the Integral of the histogram is automatically recomputed
4502/// if the number of entries is different of the number of entries when
4503/// the integral was computed last time. In case you do not use the Fill
4504/// functions to fill your histogram, but SetBinContent, you must call
4505/// TH1::ComputeIntegral before calling this function.
4506///
4507/// Getting quantiles q from two histograms and storing results in a TGraph,
4508/// a so-called QQ-plot
4509///
4510/// ~~~ {.cpp}
4511/// TGraph *gr = new TGraph(nprob);
4512/// h1->GetQuantiles(nprob,gr->GetX());
4513/// h2->GetQuantiles(nprob,gr->GetY());
4514/// gr->Draw("alp");
4515/// ~~~
4516///
4517/// Example:
4518///
4519/// ~~~ {.cpp}
4520/// void quantiles() {
4521/// // demo for quantiles
4522/// const Int_t nq = 20;
4523/// TH1F *h = new TH1F("h","demo quantiles",100,-3,3);
4524/// h->FillRandom("gaus",5000);
4525///
4526/// Double_t xq[nq]; // position where to compute the quantiles in [0,1]
4527/// Double_t yq[nq]; // array to contain the quantiles
4528/// for (Int_t i=0;i<nq;i++) xq[i] = Float_t(i+1)/nq;
4529/// h->GetQuantiles(nq,yq,xq);
4530///
4531/// //show the original histogram in the top pad
4532/// TCanvas *c1 = new TCanvas("c1","demo quantiles",10,10,700,900);
4533/// c1->Divide(1,2);
4534/// c1->cd(1);
4535/// h->Draw();
4536///
4537/// // show the quantiles in the bottom pad
4538/// c1->cd(2);
4539/// gPad->SetGrid();
4540/// TGraph *gr = new TGraph(nq,xq,yq);
4541/// gr->SetMarkerStyle(21);
4542/// gr->Draw("alp");
4543/// }
4544/// ~~~
4545
4546Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum)
4547{
4548 if (GetDimension() > 1) {
4549 Error("GetQuantiles","Only available for 1-d histograms");
4550 return 0;
4551 }
4552
4553 const Int_t nbins = GetXaxis()->GetNbins();
4554 if (!fIntegral) ComputeIntegral();
4555 if (fIntegral[nbins+1] != fEntries) ComputeIntegral();
4556
4557 Int_t i, ibin;
4558 Double_t *prob = (Double_t*)probSum;
4559 Int_t nq = nprobSum;
4560 if (probSum == 0) {
4561 nq = nbins+1;
4562 prob = new Double_t[nq];
4563 prob[0] = 0;
4564 for (i=1;i<nq;i++) {
4565 prob[i] = fIntegral[i]/fIntegral[nbins];
4566 }
4567 }
4568
4569 for (i = 0; i < nq; i++) {
4570 ibin = TMath::BinarySearch(nbins,fIntegral,prob[i]);
4571 while (ibin < nbins-1 && fIntegral[ibin+1] == prob[i]) {
4572 if (fIntegral[ibin+2] == prob[i]) ibin++;
4573 else break;
4574 }
4575 q[i] = GetBinLowEdge(ibin+1);
4576 const Double_t dint = fIntegral[ibin+1]-fIntegral[ibin];
4577 if (dint > 0) q[i] += GetBinWidth(ibin+1)*(prob[i]-fIntegral[ibin])/dint;
4578 }
4579
4580 if (!probSum) delete [] prob;
4581 return nq;
4582}
4583
4584////////////////////////////////////////////////////////////////////////////////
4585/// Decode string choptin and fill fitOption structure.
4586
4587Int_t TH1::FitOptionsMake(Option_t *choptin, Foption_t &fitOption)
4588{
4590 return 1;
4591}
4592
4593////////////////////////////////////////////////////////////////////////////////
4594/// Compute Initial values of parameters for a gaussian.
4595
4596void H1InitGaus()
4597{
4598 Double_t allcha, sumx, sumx2, x, val, stddev, mean;
4599 Int_t bin;
4600 const Double_t sqrtpi = 2.506628;
4601
4602 // - Compute mean value and StdDev of the histogram in the given range
4604 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4605 Int_t hxfirst = hFitter->GetXfirst();
4606 Int_t hxlast = hFitter->GetXlast();
4607 Double_t valmax = curHist->GetBinContent(hxfirst);
4608 Double_t binwidx = curHist->GetBinWidth(hxfirst);
4609 allcha = sumx = sumx2 = 0;
4610 for (bin=hxfirst;bin<=hxlast;bin++) {
4611 x = curHist->GetBinCenter(bin);
4612 val = TMath::Abs(curHist->GetBinContent(bin));
4613 if (val > valmax) valmax = val;
4614 sumx += val*x;
4615 sumx2 += val*x*x;
4616 allcha += val;
4617 }
4618 if (allcha == 0) return;
4619 mean = sumx/allcha;
4620 stddev = sumx2/allcha - mean*mean;
4621 if (stddev > 0) stddev = TMath::Sqrt(stddev);
4622 else stddev = 0;
4623 if (stddev == 0) stddev = binwidx*(hxlast-hxfirst+1)/4;
4624 //if the distribution is really gaussian, the best approximation
4625 //is binwidx*allcha/(sqrtpi*stddev)
4626 //However, in case of non-gaussian tails, this underestimates
4627 //the normalisation constant. In this case the maximum value
4628 //is a better approximation.
4629 //We take the average of both quantities
4630 Double_t constant = 0.5*(valmax+binwidx*allcha/(sqrtpi*stddev));
4631
4632 //In case the mean value is outside the histo limits and
4633 //the StdDev is bigger than the range, we take
4634 // mean = center of bins
4635 // stddev = half range
4636 Double_t xmin = curHist->GetXaxis()->GetXmin();
4637 Double_t xmax = curHist->GetXaxis()->GetXmax();
4638 if ((mean < xmin || mean > xmax) && stddev > (xmax-xmin)) {
4639 mean = 0.5*(xmax+xmin);
4640 stddev = 0.5*(xmax-xmin);
4641 }
4642 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4643 f1->SetParameter(0,constant);
4644 f1->SetParameter(1,mean);
4645 f1->SetParameter(2,stddev);
4646 f1->SetParLimits(2,0,10*stddev);
4647}
4648
4649////////////////////////////////////////////////////////////////////////////////
4650/// Compute Initial values of parameters for an exponential.
4651
4652void H1InitExpo()
4653{
4654 Double_t constant, slope;
4655 Int_t ifail;
4657 Int_t hxfirst = hFitter->GetXfirst();
4658 Int_t hxlast = hFitter->GetXlast();
4659 Int_t nchanx = hxlast - hxfirst + 1;
4660
4661 H1LeastSquareLinearFit(-nchanx, constant, slope, ifail);
4662
4663 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4664 f1->SetParameter(0,constant);
4665 f1->SetParameter(1,slope);
4666
4667}
4668
4669////////////////////////////////////////////////////////////////////////////////
4670/// Compute Initial values of parameters for a polynom.
4671
4672void H1InitPolynom()
4673{
4674 Double_t fitpar[25];
4675
4677 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4678 Int_t hxfirst = hFitter->GetXfirst();
4679 Int_t hxlast = hFitter->GetXlast();
4680 Int_t nchanx = hxlast - hxfirst + 1;
4681 Int_t npar = f1->GetNpar();
4682
4683 if (nchanx <=1 || npar == 1) {
4684 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4685 fitpar[0] = curHist->GetSumOfWeights()/Double_t(nchanx);
4686 } else {
4687 H1LeastSquareFit( nchanx, npar, fitpar);
4688 }
4689 for (Int_t i=0;i<npar;i++) f1->SetParameter(i, fitpar[i]);
4690}
4691
4692////////////////////////////////////////////////////////////////////////////////
4693/// Least squares lpolynomial fitting without weights.
4694///
4695/// \param[in] n number of points to fit
4696/// \param[in] m number of parameters
4697/// \param[in] a array of parameters
4698///
4699/// based on CERNLIB routine LSQ: Translated to C++ by Rene Brun
4700/// (E.Keil. revised by B.Schorr, 23.10.1981.)
4701
4703{
4704 const Double_t zero = 0.;
4705 const Double_t one = 1.;
4706 const Int_t idim = 20;
4707
4708 Double_t b[400] /* was [20][20] */;
4709 Int_t i, k, l, ifail;
4710 Double_t power;
4711 Double_t da[20], xk, yk;
4712
4713 if (m <= 2) {
4714 H1LeastSquareLinearFit(n, a[0], a[1], ifail);
4715 return;
4716 }
4717 if (m > idim || m > n) return;
4718 b[0] = Double_t(n);
4719 da[0] = zero;
4720 for (l = 2; l <= m; ++l) {
4721 b[l-1] = zero;
4722 b[m + l*20 - 21] = zero;
4723 da[l-1] = zero;
4724 }
4726 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4727 Int_t hxfirst = hFitter->GetXfirst();
4728 Int_t hxlast = hFitter->GetXlast();
4729 for (k = hxfirst; k <= hxlast; ++k) {
4730 xk = curHist->GetBinCenter(k);
4731 yk = curHist->GetBinContent(k);
4732 power = one;
4733 da[0] += yk;
4734 for (l = 2; l <= m; ++l) {
4735 power *= xk;
4736 b[l-1] += power;
4737 da[l-1] += power*yk;
4738 }
4739 for (l = 2; l <= m; ++l) {
4740 power *= xk;
4741 b[m + l*20 - 21] += power;
4742 }
4743 }
4744 for (i = 3; i <= m; ++i) {
4745 for (k = i; k <= m; ++k) {
4746 b[k - 1 + (i-1)*20 - 21] = b[k + (i-2)*20 - 21];
4747 }
4748 }
4749 H1LeastSquareSeqnd(m, b, idim, ifail, 1, da);
4750
4751 for (i=0; i<m; ++i) a[i] = da[i];
4752
4753}
4754
4755////////////////////////////////////////////////////////////////////////////////
4756/// Least square linear fit without weights.
4757///
4758/// extracted from CERNLIB LLSQ: Translated to C++ by Rene Brun
4759/// (added to LSQ by B. Schorr, 15.02.1982.)
4760
4761void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail)
4762{
4763 Double_t xbar, ybar, x2bar;
4764 Int_t i, n;
4765 Double_t xybar;
4766 Double_t fn, xk, yk;
4767 Double_t det;
4768
4769 n = TMath::Abs(ndata);
4770 ifail = -2;
4771 xbar = ybar = x2bar = xybar = 0;
4773 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4774 Int_t hxfirst = hFitter->GetXfirst();
4775 Int_t hxlast = hFitter->GetXlast();
4776 for (i = hxfirst; i <= hxlast; ++i) {
4777 xk = curHist->GetBinCenter(i);
4778 yk = curHist->GetBinContent(i);
4779 if (ndata < 0) {
4780 if (yk <= 0) yk = 1e-9;
4781 yk = TMath::Log(yk);
4782 }
4783 xbar += xk;
4784 ybar += yk;
4785 x2bar += xk*xk;
4786 xybar += xk*yk;
4787 }
4788 fn = Double_t(n);
4789 det = fn*x2bar - xbar*xbar;
4790 ifail = -1;
4791 if (det <= 0) {
4792 a0 = ybar/fn;
4793 a1 = 0;
4794 return;
4795 }
4796 ifail = 0;
4797 a0 = (x2bar*ybar - xbar*xybar) / det;
4798 a1 = (fn*xybar - xbar*ybar) / det;
4799
4800}
4801
4802////////////////////////////////////////////////////////////////////////////////
4803/// Extracted from CERN Program library routine DSEQN.
4804///
4805/// Translated to C++ by Rene Brun
4806
4807void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b)
4808{
4809 Int_t a_dim1, a_offset, b_dim1, b_offset;
4810 Int_t nmjp1, i, j, l;
4811 Int_t im1, jp1, nm1, nmi;
4812 Double_t s1, s21, s22;
4813 const Double_t one = 1.;
4814
4815 /* Parameter adjustments */
4816 b_dim1 = idim;
4817 b_offset = b_dim1 + 1;
4818 b -= b_offset;
4819 a_dim1 = idim;
4820 a_offset = a_dim1 + 1;
4821 a -= a_offset;
4822
4823 if (idim < n) return;
4824
4825 ifail = 0;
4826 for (j = 1; j <= n; ++j) {
4827 if (a[j + j*a_dim1] <= 0) { ifail = -1; return; }
4828 a[j + j*a_dim1] = one / a[j + j*a_dim1];
4829 if (j == n) continue;
4830 jp1 = j + 1;
4831 for (l = jp1; l <= n; ++l) {
4832 a[j + l*a_dim1] = a[j + j*a_dim1] * a[l + j*a_dim1];
4833 s1 = -a[l + (j+1)*a_dim1];
4834 for (i = 1; i <= j; ++i) { s1 = a[l + i*a_dim1] * a[i + (j+1)*a_dim1] + s1; }
4835 a[l + (j+1)*a_dim1] = -s1;
4836 }
4837 }
4838 if (k <= 0) return;
4839
4840 for (l = 1; l <= k; ++l) {
4841 b[l*b_dim1 + 1] = a[a_dim1 + 1]*b[l*b_dim1 + 1];
4842 }
4843 if (n == 1) return;
4844 for (l = 1; l <= k; ++l) {
4845 for (i = 2; i <= n; ++i) {
4846 im1 = i - 1;
4847 s21 = -b[i + l*b_dim1];
4848 for (j = 1; j <= im1; ++j) {
4849 s21 = a[i + j*a_dim1]*b[j + l*b_dim1] + s21;
4850 }
4851 b[i + l*b_dim1] = -a[i + i*a_dim1]*s21;
4852 }
4853 nm1 = n - 1;
4854 for (i = 1; i <= nm1; ++i) {
4855 nmi = n - i;
4856 s22 = -b[nmi + l*b_dim1];
4857 for (j = 1; j <= i; ++j) {
4858 nmjp1 = n - j + 1;
4859 s22 = a[nmi + nmjp1*a_dim1]*b[nmjp1 + l*b_dim1] + s22;
4860 }
4861 b[nmi + l*b_dim1] = -s22;
4862 }
4863 }
4864}
4865
4866////////////////////////////////////////////////////////////////////////////////
4867/// Return Global bin number corresponding to binx,y,z.
4868///
4869/// 2-D and 3-D histograms are represented with a one dimensional
4870/// structure.
4871/// This has the advantage that all existing functions, such as
4872/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
4873///
4874/// In case of a TH1x, returns binx directly.
4875/// see TH1::GetBinXYZ for the inverse transformation.
4876///
4877/// Convention for numbering bins
4878///
4879/// For all histogram types: nbins, xlow, xup
4880///
4881/// - bin = 0; underflow bin
4882/// - bin = 1; first bin with low-edge xlow INCLUDED
4883/// - bin = nbins; last bin with upper-edge xup EXCLUDED
4884/// - bin = nbins+1; overflow bin
4885///
4886/// In case of 2-D or 3-D histograms, a "global bin" number is defined.
4887/// For example, assuming a 3-D histogram with binx,biny,binz, the function
4888///
4889/// ~~~ {.cpp}
4890/// Int_t bin = h->GetBin(binx,biny,binz);
4891/// ~~~
4892///
4893/// returns a global/linearized bin number. This global bin is useful
4894/// to access the bin information independently of the dimension.
4895
4896Int_t TH1::GetBin(Int_t binx, Int_t, Int_t) const
4897{
4898 Int_t ofx = fXaxis.GetNbins() + 1; // overflow bin
4899 if (binx < 0) binx = 0;
4900 if (binx > ofx) binx = ofx;
4901
4902 return binx;
4903}
4904
4905////////////////////////////////////////////////////////////////////////////////
4906/// Return binx, biny, binz corresponding to the global bin number globalbin
4907/// see TH1::GetBin function above
4908
4909void TH1::GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const
4910{
4911 Int_t nx = fXaxis.GetNbins()+2;
4912 Int_t ny = fYaxis.GetNbins()+2;
4913
4914 if (GetDimension() == 1) {
4915 binx = binglobal%nx;
4916 biny = 0;
4917 binz = 0;
4918 return;
4919 }
4920 if (GetDimension() == 2) {
4921 binx = binglobal%nx;
4922 biny = ((binglobal-binx)/nx)%ny;
4923 binz = 0;
4924 return;
4925 }
4926 if (GetDimension() == 3) {
4927 binx = binglobal%nx;
4928 biny = ((binglobal-binx)/nx)%ny;
4929 binz = ((binglobal-binx)/nx -biny)/ny;
4930 }
4931}
4932
4933////////////////////////////////////////////////////////////////////////////////
4934/// Return a random number distributed according the histogram bin contents.
4935/// This function checks if the bins integral exists. If not, the integral
4936/// is evaluated, normalized to one.
4937///
4938/// @param rng (optional) Random number generator pointer used (default is gRandom)
4939///
4940/// The integral is automatically recomputed if the number of entries
4941/// is not the same then when the integral was computed.
4942/// NB Only valid for 1-d histograms. Use GetRandom2 or 3 otherwise.
4943/// If the histogram has a bin with negative content a NaN is returned
4944
4945Double_t TH1::GetRandom(TRandom * rng) const
4946{
4947 if (fDimension > 1) {
4948 Error("GetRandom","Function only valid for 1-d histograms");
4949 return 0;
4950 }
4951 Int_t nbinsx = GetNbinsX();
4952 Double_t integral = 0;
4953 // compute integral checking that all bins have positive content (see ROOT-5894)
4954 if (fIntegral) {
4955 if (fIntegral[nbinsx+1] != fEntries) integral = ((TH1*)this)->ComputeIntegral(true);
4956 else integral = fIntegral[nbinsx];
4957 } else {
4958 integral = ((TH1*)this)->ComputeIntegral(true);
4959 }
4960 if (integral == 0) return 0;
4961 // return a NaN in case some bins have negative content
4962 if (integral == TMath::QuietNaN() ) return TMath::QuietNaN();
4963
4964 Double_t r1 = (rng) ? rng->Rndm() : gRandom->Rndm();
4965 Int_t ibin = TMath::BinarySearch(nbinsx,fIntegral,r1);
4966 Double_t x = GetBinLowEdge(ibin+1);
4967 if (r1 > fIntegral[ibin]) x +=
4968 GetBinWidth(ibin+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]);
4969 return x;
4970}
4971
4972////////////////////////////////////////////////////////////////////////////////
4973/// Return content of bin number bin.
4974///
4975/// Implemented in TH1C,S,F,D
4976///
4977/// Convention for numbering bins
4978///
4979/// For all histogram types: nbins, xlow, xup
4980///
4981/// - bin = 0; underflow bin
4982/// - bin = 1; first bin with low-edge xlow INCLUDED
4983/// - bin = nbins; last bin with upper-edge xup EXCLUDED
4984/// - bin = nbins+1; overflow bin
4985///
4986/// In case of 2-D or 3-D histograms, a "global bin" number is defined.
4987/// For example, assuming a 3-D histogram with binx,biny,binz, the function
4988///
4989/// ~~~ {.cpp}
4990/// Int_t bin = h->GetBin(binx,biny,binz);
4991/// ~~~
4992///
4993/// returns a global/linearized bin number. This global bin is useful
4994/// to access the bin information independently of the dimension.
4995
4997{
4998 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
4999 if (bin < 0) bin = 0;
5000 if (bin >= fNcells) bin = fNcells-1;
5001
5002 return RetrieveBinContent(bin);
5003}
5004
5005////////////////////////////////////////////////////////////////////////////////
5006/// Compute first binx in the range [firstx,lastx] for which
5007/// diff = abs(bin_content-c) <= maxdiff
5008///
5009/// In case several bins in the specified range with diff=0 are found
5010/// the first bin found is returned in binx.
5011/// In case several bins in the specified range satisfy diff <=maxdiff
5012/// the bin with the smallest difference is returned in binx.
5013/// In all cases the function returns the smallest difference.
5014///
5015/// NOTE1: if firstx <= 0, firstx is set to bin 1
5016/// if (lastx < firstx then firstx is set to the number of bins
5017/// ie if firstx=0 and lastx=0 (default) the search is on all bins.
5018///
5019/// NOTE2: if maxdiff=0 (default), the first bin with content=c is returned.
5020
5021Double_t TH1::GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx, Int_t lastx,Double_t maxdiff) const
5022{
5023 if (fDimension > 1) {
5024 binx = 0;
5025 Error("GetBinWithContent","function is only valid for 1-D histograms");
5026 return 0;
5027 }
5028
5029 if (fBuffer) ((TH1*)this)->BufferEmpty();
5030
5031 if (firstx <= 0) firstx = 1;
5032 if (lastx < firstx) lastx = fXaxis.GetNbins();
5033 Int_t binminx = 0;
5034 Double_t diff, curmax = 1.e240;
5035 for (Int_t i=firstx;i<=lastx;i++) {
5036 diff = TMath::Abs(RetrieveBinContent(i)-c);
5037 if (diff <= 0) {binx = i; return diff;}
5038 if (diff < curmax && diff <= maxdiff) {curmax = diff, binminx=i;}
5039 }
5040 binx = binminx;
5041 return curmax;
5042}
5043
5044////////////////////////////////////////////////////////////////////////////////
5045/// Given a point x, approximates the value via linear interpolation
5046/// based on the two nearest bin centers
5047///
5048/// Andy Mastbaum 10/21/08
5049
5051{
5052 if (fBuffer) ((TH1*)this)->BufferEmpty();
5053
5054 Int_t xbin = fXaxis.FindFixBin(x);
5055 Double_t x0,x1,y0,y1;
5056
5057 if(x<=GetBinCenter(1)) {
5058 return RetrieveBinContent(1);
5059 } else if(x>=GetBinCenter(GetNbinsX())) {
5060 return RetrieveBinContent(GetNbinsX());
5061 } else {
5062 if(x<=GetBinCenter(xbin)) {
5063 y0 = RetrieveBinContent(xbin-1);
5064 x0 = GetBinCenter(xbin-1);
5065 y1 = RetrieveBinContent(xbin);
5066 x1 = GetBinCenter(xbin);
5067 } else {
5068 y0 = RetrieveBinContent(xbin);
5069 x0 = GetBinCenter(xbin);
5070 y1 = RetrieveBinContent(xbin+1);
5071 x1 = GetBinCenter(xbin+1);
5072 }
5073 return y0 + (x-x0)*((y1-y0)/(x1-x0));
5074 }
5075}
5076
5077////////////////////////////////////////////////////////////////////////////////
5078/// 2d Interpolation. Not yet implemented.
5079
5081{
5082 Error("Interpolate","This function must be called with 1 argument for a TH1");
5083 return 0;
5084}
5085
5086////////////////////////////////////////////////////////////////////////////////
5087/// 3d Interpolation. Not yet implemented.
5088
5090{
5091 Error("Interpolate","This function must be called with 1 argument for a TH1");
5092 return 0;
5093}
5094
5095///////////////////////////////////////////////////////////////////////////////
5096/// Check if an histogram is empty
5097/// (this a protected method used mainly by TH1Merger )
5098
5099Bool_t TH1::IsEmpty() const
5100{
5101 // if fTsumw or fentries are not zero histogram is not empty
5102 // need to use GetEntries() instead of fEntries in case of bugger histograms
5103 // so we will flash the buffer
5104