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