Logo ROOT  
Reference Guide
TH1.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Rene Brun 26/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include <cstdlib>
13#include <cstring>
14#include <cstdio>
15#include <cctype>
16#include <climits>
17#include <sstream>
18#include <cmath>
19#include <iostream>
20
21#include "TROOT.h"
22#include "TBuffer.h"
23#include "TEnv.h"
24#include "TClass.h"
25#include "TMath.h"
26#include "THashList.h"
27#include "TH1.h"
28#include "TH2.h"
29#include "TH3.h"
30#include "TF2.h"
31#include "TF3.h"
32#include "TPluginManager.h"
33#include "TVirtualPad.h"
34#include "TRandom.h"
35#include "TVirtualFitter.h"
36#include "THLimitsFinder.h"
37#include "TProfile.h"
38#include "TStyle.h"
39#include "TVectorF.h"
40#include "TVectorD.h"
41#include "TBrowser.h"
42#include "TError.h"
43#include "TVirtualHistPainter.h"
44#include "TVirtualFFT.h"
45#include "TVirtualPaveStats.h"
46
47#include "HFitInterface.h"
48#include "Fit/DataRange.h"
49#include "Fit/BinData.h"
50#include "Math/GoFTest.h"
53
54#include "TH1Merger.h"
55
56/** \addtogroup Histograms
57@{
58\class TH1C
59\brief 1-D histogram with a byte per channel (see TH1 documentation)
60\class TH1S
61\brief 1-D histogram with a short per channel (see TH1 documentation)
62\class TH1I
63\brief 1-D histogram with an int per channel (see TH1 documentation)}
64\class TH1F
65\brief 1-D histogram with a float per channel (see TH1 documentation)}
66\class TH1D
67\brief 1-D histogram with a double per channel (see TH1 documentation)}
68@}
69*/
70
71/** \class TH1
72 \ingroup Histograms
73TH1 is the base class of all histogram classes in %ROOT.
74
75It provides the common interface for operations such as binning, filling, drawing, which
76will be detailed below.
77
78-# [Creating histograms](\ref creating-histograms)
79 - [Labelling axes](\ref labelling-axis)
80-# [Binning](\ref binning)
81 - [Fix or variable bin size](\ref fix-var)
82 - [Convention for numbering bins](\ref convention)
83 - [Alphanumeric Bin Labels](\ref alpha)
84 - [Histograms with automatic bins](\ref auto-bin)
85 - [Rebinning](\ref rebinning)
86-# [Filling histograms](\ref filling-histograms)
87 - [Associated errors](\ref associated-errors)
88 - [Associated functions](\ref associated-functions)
89 - [Projections of histograms](\ref prof-hist)
90 - [Random Numbers and histograms](\ref random-numbers)
91 - [Making a copy of a histogram](\ref making-a-copy)
92 - [Normalizing histograms](\ref normalizing)
93-# [Drawing histograms](\ref drawing-histograms)
94 - [Setting Drawing histogram contour levels (2-D hists only)](\ref cont-level)
95 - [Setting histogram graphics attributes](\ref graph-att)
96 - [Customising how axes are drawn](\ref axis-drawing)
97-# [Fitting histograms](\ref fitting-histograms)
98-# [Saving/reading histograms to/from a ROOT file](\ref saving-histograms)
99-# [Operations on histograms](\ref operations-on-histograms)
100-# [Miscellaneous operations](\ref misc)
101
102ROOT supports the following histogram types:
103
104 - 1-D histograms:
105 - TH1C : histograms with one byte per channel. Maximum bin content = 127
106 - TH1S : histograms with one short per channel. Maximum bin content = 32767
107 - TH1I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
108 - TH1F : histograms with one float per channel. Maximum precision 7 digits
109 - TH1D : histograms with one double per channel. Maximum precision 14 digits
110 - 2-D histograms:
111 - TH2C : histograms with one byte per channel. Maximum bin content = 127
112 - TH2S : histograms with one short per channel. Maximum bin content = 32767
113 - TH2I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
114 - TH2F : histograms with one float per channel. Maximum precision 7 digits
115 - TH2D : histograms with one double per channel. Maximum precision 14 digits
116 - 3-D histograms:
117 - TH3C : histograms with one byte per channel. Maximum bin content = 127
118 - TH3S : histograms with one short per channel. Maximum bin content = 32767
119 - TH3I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
120 - TH3F : histograms with one float per channel. Maximum precision 7 digits
121 - TH3D : histograms with one double per channel. Maximum precision 14 digits
122 - Profile histograms: See classes TProfile, TProfile2D and TProfile3D.
123 Profile histograms are used to display the mean value of Y and its standard deviation
124 for each bin in X. Profile histograms are in many cases an elegant
125 replacement of two-dimensional histograms : the inter-relation of two
126 measured quantities X and Y can always be visualized by a two-dimensional
127 histogram or scatter-plot; If Y is an unknown (but single-valued)
128 approximate function of X, this function is displayed by a profile
129 histogram with much better precision than by a scatter-plot.
130
131<sup>
132\anchor intmax (*) INT_MAX = 2147483647 is the [maximum value for a variable of type int.](https://docs.microsoft.com/en-us/cpp/c-language/cpp-integer-limits)
133</sup>
134
135The inheritance hierarchy looks as follows:
136
137\image html classTH1__inherit__graph_org.svg width=100%
138
139\anchor creating-histograms
140## Creating histograms
141
142Histograms are created by invoking one of the constructors, e.g.
143~~~ {.cpp}
144 TH1F *h1 = new TH1F("h1", "h1 title", 100, 0, 4.4);
145 TH2F *h2 = new TH2F("h2", "h2 title", 40, 0, 4, 30, -3, 3);
146~~~
147Histograms may also be created by:
148
149 - calling the Clone() function, see below
150 - making a projection from a 2-D or 3-D histogram, see below
151 - reading a histogram from a file
152
153 When a histogram is created, a reference to it is automatically added
154 to the list of in-memory objects for the current file or directory.
155 Then the pointer to this histogram in the current directory can be found
156 by its name, doing:
157~~~ {.cpp}
158 TH1F *h1 = (TH1F*)gDirectory->FindObject(name);
159~~~
160
161 This default behaviour can be changed by:
162~~~ {.cpp}
163 h->SetDirectory(nullptr); // for the current histogram h
164 TH1::AddDirectory(kFALSE); // sets a global switch disabling the referencing
165~~~
166 When the histogram is deleted, the reference to it is removed from
167 the list of objects in memory.
168 When a file is closed, all histograms in memory associated with this file
169 are automatically deleted.
170
171\anchor labelling-axis
172### Labelling axes
173
174 Axis titles can be specified in the title argument of the constructor.
175 They must be separated by ";":
176~~~ {.cpp}
177 TH1F* h=new TH1F("h", "Histogram title;X Axis;Y Axis", 100, 0, 1);
178~~~
179 The histogram title and the axis titles can be any TLatex string, and
180 are persisted if a histogram is written to a file.
181
182 Any title can be omitted:
183~~~ {.cpp}
184 TH1F* h=new TH1F("h", "Histogram title;;Y Axis", 100, 0, 1);
185 TH1F* h=new TH1F("h", ";;Y Axis", 100, 0, 1);
186~~~
187 The method SetTitle() has the same syntax:
188~~~ {.cpp}
189 h->SetTitle("Histogram title;Another X title Axis");
190~~~
191Alternatively, the title of each axis can be set directly:
192~~~ {.cpp}
193 h->GetXaxis()->SetTitle("X axis title");
194 h->GetYaxis()->SetTitle("Y axis title");
195~~~
196For bin labels see \ref binning.
197
198\anchor binning
199## Binning
200
201\anchor fix-var
202### Fix or variable bin size
203
204 All histogram types support either fix or variable bin sizes.
205 2-D histograms may have fix size bins along X and variable size bins
206 along Y or vice-versa. The functions to fill, manipulate, draw or access
207 histograms are identical in both cases.
208
209 Each histogram always contains 3 axis objects of type TAxis: fXaxis, fYaxis and fZaxis.
210 To access the axis parameters, use:
211~~~ {.cpp}
212 TAxis *xaxis = h->GetXaxis(); etc.
213 Double_t binCenter = xaxis->GetBinCenter(bin), etc.
214~~~
215 See class TAxis for a description of all the access functions.
216 The axis range is always stored internally in double precision.
217
218\anchor convention
219### Convention for numbering bins
220
221 For all histogram types: nbins, xlow, xup
222~~~ {.cpp}
223 bin = 0; underflow bin
224 bin = 1; first bin with low-edge xlow INCLUDED
225 bin = nbins; last bin with upper-edge xup EXCLUDED
226 bin = nbins+1; overflow bin
227~~~
228 In case of 2-D or 3-D histograms, a "global bin" number is defined.
229 For example, assuming a 3-D histogram with (binx, biny, binz), the function
230~~~ {.cpp}
231 Int_t gbin = h->GetBin(binx, biny, binz);
232~~~
233 returns a global/linearized gbin number. This global gbin is useful
234 to access the bin content/error information independently of the dimension.
235 Note that to access the information other than bin content and errors
236 one should use the TAxis object directly with e.g.:
237~~~ {.cpp}
238 Double_t xcenter = h3->GetZaxis()->GetBinCenter(27);
239~~~
240 returns the center along z of bin number 27 (not the global bin)
241 in the 3-D histogram h3.
242
243\anchor alpha
244### Alphanumeric Bin Labels
245
246 By default, a histogram axis is drawn with its numeric bin labels.
247 One can specify alphanumeric labels instead with:
248
249 - call TAxis::SetBinLabel(bin, label);
250 This can always be done before or after filling.
251 When the histogram is drawn, bin labels will be automatically drawn.
252 See examples labels1.C and labels2.C
253 - call to a Fill function with one of the arguments being a string, e.g.
254~~~ {.cpp}
255 hist1->Fill(somename, weight);
256 hist2->Fill(x, somename, weight);
257 hist2->Fill(somename, y, weight);
258 hist2->Fill(somenamex, somenamey, weight);
259~~~
260 See examples hlabels1.C and hlabels2.C
261 - via TTree::Draw. see for example cernstaff.C
262~~~ {.cpp}
263 tree.Draw("Nation::Division");
264~~~
265 where "Nation" and "Division" are two branches of a Tree.
266
267When using the options 2 or 3 above, the labels are automatically
268 added to the list (THashList) of labels for a given axis.
269 By default, an axis is drawn with the order of bins corresponding
270 to the filling sequence. It is possible to reorder the axis
271
272 - alphabetically
273 - by increasing or decreasing values
274
275 The reordering can be triggered via the TAxis context menu by selecting
276 the menu item "LabelsOption" or by calling directly
277 TH1::LabelsOption(option, axis) where
278
279 - axis may be "X", "Y" or "Z"
280 - option may be:
281 - "a" sort by alphabetic order
282 - ">" sort by decreasing values
283 - "<" sort by increasing values
284 - "h" draw labels horizontal
285 - "v" draw labels vertical
286 - "u" draw labels up (end of label right adjusted)
287 - "d" draw labels down (start of label left adjusted)
288
289 When using the option 2 above, new labels are added by doubling the current
290 number of bins in case one label does not exist yet.
291 When the Filling is terminated, it is possible to trim the number
292 of bins to match the number of active labels by calling
293~~~ {.cpp}
294 TH1::LabelsDeflate(axis) with axis = "X", "Y" or "Z"
295~~~
296 This operation is automatic when using TTree::Draw.
297 Once bin labels have been created, they become persistent if the histogram
298 is written to a file or when generating the C++ code via SavePrimitive.
299
300\anchor auto-bin
301### Histograms with automatic bins
302
303 When a histogram is created with an axis lower limit greater or equal
304 to its upper limit, the SetBuffer is automatically called with an
305 argument fBufferSize equal to fgBufferSize (default value=1000).
306 fgBufferSize may be reset via the static function TH1::SetDefaultBufferSize.
307 The axis limits will be automatically computed when the buffer will
308 be full or when the function BufferEmpty is called.
309
310\anchor rebinning
311### Rebinning
312
313 At any time, a histogram can be rebinned via TH1::Rebin. This function
314 returns a new histogram with the rebinned contents.
315 If bin errors were stored, they are recomputed during the rebinning.
316
317
318\anchor filling-histograms
319## Filling histograms
320
321 A histogram is typically filled with statements like:
322~~~ {.cpp}
323 h1->Fill(x);
324 h1->Fill(x, w); //fill with weight
325 h2->Fill(x, y)
326 h2->Fill(x, y, w)
327 h3->Fill(x, y, z)
328 h3->Fill(x, y, z, w)
329~~~
330 or via one of the Fill functions accepting names described above.
331 The Fill functions compute the bin number corresponding to the given
332 x, y or z argument and increment this bin by the given weight.
333 The Fill functions return the bin number for 1-D histograms or global
334 bin number for 2-D and 3-D histograms.
335 If TH1::Sumw2 has been called before filling, the sum of squares of
336 weights is also stored.
337 One can also increment directly a bin number via TH1::AddBinContent
338 or replace the existing content via TH1::SetBinContent.
339 To access the bin content of a given bin, do:
340~~~ {.cpp}
341 Double_t binContent = h->GetBinContent(bin);
342~~~
343
344 By default, the bin number is computed using the current axis ranges.
345 If the automatic binning option has been set via
346~~~ {.cpp}
347 h->SetCanExtend(TH1::kAllAxes);
348~~~
349 then, the Fill Function will automatically extend the axis range to
350 accomodate the new value specified in the Fill argument. The method
351 used is to double the bin size until the new value fits in the range,
352 merging bins two by two. This automatic binning options is extensively
353 used by the TTree::Draw function when histogramming Tree variables
354 with an unknown range.
355 This automatic binning option is supported for 1-D, 2-D and 3-D histograms.
356
357 During filling, some statistics parameters are incremented to compute
358 the mean value and Root Mean Square with the maximum precision.
359
360 In case of histograms of type TH1C, TH1S, TH2C, TH2S, TH3C, TH3S
361 a check is made that the bin contents do not exceed the maximum positive
362 capacity (127 or 32767). Histograms of all types may have positive
363 or/and negative bin contents.
364
365\anchor associated-errors
366### Associated errors
367 By default, for each bin, the sum of weights is computed at fill time.
368 One can also call TH1::Sumw2 to force the storage and computation
369 of the sum of the square of weights per bin.
370 If Sumw2 has been called, the error per bin is computed as the
371 sqrt(sum of squares of weights), otherwise the error is set equal
372 to the sqrt(bin content).
373 To return the error for a given bin number, do:
374~~~ {.cpp}
375 Double_t error = h->GetBinError(bin);
376~~~
377
378\anchor associated-functions
379### Associated functions
380 One or more object (typically a TF1*) can be added to the list
381 of functions (fFunctions) associated to each histogram.
382 When TH1::Fit is invoked, the fitted function is added to this list.
383 Given a histogram h, one can retrieve an associated function
384 with:
385~~~ {.cpp}
386 TF1 *myfunc = h->GetFunction("myfunc");
387~~~
388
389
390\anchor operations-on-histograms
391## Operations on histograms
392
393 Many types of operations are supported on histograms or between histograms
394
395 - Addition of a histogram to the current histogram.
396 - Additions of two histograms with coefficients and storage into the current
397 histogram.
398 - Multiplications and Divisions are supported in the same way as additions.
399 - The Add, Divide and Multiply functions also exist to add, divide or multiply
400 a histogram by a function.
401
402 If a histogram has associated error bars (TH1::Sumw2 has been called),
403 the resulting error bars are also computed assuming independent histograms.
404 In case of divisions, Binomial errors are also supported.
405 One can mark a histogram to be an "average" histogram by setting its bit kIsAverage via
406 myhist.SetBit(TH1::kIsAverage);
407 When adding (see TH1::Add) average histograms, the histograms are averaged and not summed.
408
409
410\anchor prof-hist
411### Projections of histograms
412
413 One can:
414
415 - make a 1-D projection of a 2-D histogram or Profile
416 see functions TH2::ProjectionX,Y, TH2::ProfileX,Y, TProfile::ProjectionX
417 - make a 1-D, 2-D or profile out of a 3-D histogram
418 see functions TH3::ProjectionZ, TH3::Project3D.
419
420 One can fit these projections via:
421~~~ {.cpp}
422 TH2::FitSlicesX,Y, TH3::FitSlicesZ.
423~~~
424
425\anchor random-numbers
426### Random Numbers and histograms
427
428 TH1::FillRandom can be used to randomly fill a histogram using
429 the contents of an existing TF1 function or another
430 TH1 histogram (for all dimensions).
431 For example, the following two statements create and fill a histogram
432 10000 times with a default gaussian distribution of mean 0 and sigma 1:
433~~~ {.cpp}
434 TH1F h1("h1", "histo from a gaussian", 100, -3, 3);
435 h1.FillRandom("gaus", 10000);
436~~~
437 TH1::GetRandom can be used to return a random number distributed
438 according to the contents of a histogram.
439
440\anchor making-a-copy
441### Making a copy of a histogram
442 Like for any other ROOT object derived from TObject, one can use
443 the Clone() function. This makes an identical copy of the original
444 histogram including all associated errors and functions, e.g.:
445~~~ {.cpp}
446 TH1F *hnew = (TH1F*)h->Clone("hnew");
447~~~
448
449\anchor normalizing
450### Normalizing histograms
451
452 One can scale a histogram such that the bins integral is equal to
453 the normalization parameter via TH1::Scale(Double_t norm), where norm
454 is the desired normalization divided by the integral of the histogram.
455
456
457\anchor drawing-histograms
458## Drawing histograms
459
460 Histograms are drawn via the THistPainter class. Each histogram has
461 a pointer to its own painter (to be usable in a multithreaded program).
462 Many drawing options are supported.
463 See THistPainter::Paint() for more details.
464
465 The same histogram can be drawn with different options in different pads.
466 When a histogram drawn in a pad is deleted, the histogram is
467 automatically removed from the pad or pads where it was drawn.
468 If a histogram is drawn in a pad, then filled again, the new status
469 of the histogram will be automatically shown in the pad next time
470 the pad is updated. One does not need to redraw the histogram.
471 To draw the current version of a histogram in a pad, one can use
472~~~ {.cpp}
473 h->DrawCopy();
474~~~
475 This makes a clone (see Clone below) of the histogram. Once the clone
476 is drawn, the original histogram may be modified or deleted without
477 affecting the aspect of the clone.
478
479 One can use TH1::SetMaximum() and TH1::SetMinimum() to force a particular
480 value for the maximum or the minimum scale on the plot. (For 1-D
481 histograms this means the y-axis, while for 2-D histograms these
482 functions affect the z-axis).
483
484 TH1::UseCurrentStyle() can be used to change all histogram graphics
485 attributes to correspond to the current selected style.
486 This function must be called for each histogram.
487 In case one reads and draws many histograms from a file, one can force
488 the histograms to inherit automatically the current graphics style
489 by calling before gROOT->ForceStyle().
490
491\anchor cont-level
492### Setting Drawing histogram contour levels (2-D hists only)
493
494 By default contours are automatically generated at equidistant
495 intervals. A default value of 20 levels is used. This can be modified
496 via TH1::SetContour() or TH1::SetContourLevel().
497 the contours level info is used by the drawing options "cont", "surf",
498 and "lego".
499
500\anchor graph-att
501### Setting histogram graphics attributes
502
503 The histogram classes inherit from the attribute classes:
504 TAttLine, TAttFill, and TAttMarker.
505 See the member functions of these classes for the list of options.
506
507\anchor axis-drawing
508### Customizing how axes are drawn
509
510 Use the functions of TAxis, such as
511~~~ {.cpp}
512 histogram.GetXaxis()->SetTicks("+");
513 histogram.GetYaxis()->SetRangeUser(1., 5.);
514~~~
515
516\anchor fitting-histograms
517## Fitting histograms
518
519 Histograms (1-D, 2-D, 3-D and Profiles) can be fitted with a user
520 specified function or a pre-defined function via TH1::Fit.
521 See TH1::Fit(TF1*, Option_t *, Option_t *, Double_t, Double_t) for the fitting documentation and the possible [fitting options](\ref HFitOpt)
522
523 The FitPanel can also be used for fitting an histogram. See the [FitPanel documentation](https://root.cern/manual/fitting/#using-the-fit-panel).
524
525\anchor saving-histograms
526## Saving/reading histograms to/from a ROOT file
527
528 The following statements create a ROOT file and store a histogram
529 on the file. Because TH1 derives from TNamed, the key identifier on
530 the file is the histogram name:
531~~~ {.cpp}
532 TFile f("histos.root", "new");
533 TH1F h1("hgaus", "histo from a gaussian", 100, -3, 3);
534 h1.FillRandom("gaus", 10000);
535 h1->Write();
536~~~
537 To read this histogram in another Root session, do:
538~~~ {.cpp}
539 TFile f("histos.root");
540 TH1F *h = (TH1F*)f.Get("hgaus");
541~~~
542 One can save all histograms in memory to the file by:
543~~~ {.cpp}
544 file->Write();
545~~~
546
547
548\anchor misc
549## Miscellaneous operations
550
551~~~ {.cpp}
552 TH1::KolmogorovTest(): statistical test of compatibility in shape
553 between two histograms
554 TH1::Smooth() smooths the bin contents of a 1-d histogram
555 TH1::Integral() returns the integral of bin contents in a given bin range
556 TH1::GetMean(int axis) returns the mean value along axis
557 TH1::GetStdDev(int axis) returns the sigma distribution along axis
558 TH1::GetEntries() returns the number of entries
559 TH1::Reset() resets the bin contents and errors of a histogram
560~~~
561 IMPORTANT NOTE: The returned values for GetMean and GetStdDev depend on how the
562 histogram statistics are calculated. By default, if no range has been set, the
563 returned values are the (unbinned) ones calculated at fill time. If a range has been
564 set, however, the values are calculated using the bins in range; THIS IS TRUE EVEN
565 IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset the range.
566 To ensure that the returned values are always those of the binned data stored in the
567 histogram, call TH1::ResetStats. See TH1::GetStats.
568*/
569
570TF1 *gF1=0; //left for back compatibility (use TVirtualFitter::GetUserFunc instead)
571
576
577extern void H1InitGaus();
578extern void H1InitExpo();
579extern void H1InitPolynom();
580extern void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a);
581extern void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail);
582extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b);
583
584// Internal exceptions for the CheckConsistency method
585class DifferentDimension: public std::exception {};
586class DifferentNumberOfBins: public std::exception {};
587class DifferentAxisLimits: public std::exception {};
588class DifferentBinLimits: public std::exception {};
589class DifferentLabels: public std::exception {};
590
592
593////////////////////////////////////////////////////////////////////////////////
594/// Histogram default constructor.
595
597{
598 fDirectory = nullptr;
599 fFunctions = new TList;
600 fNcells = 0;
601 fIntegral = nullptr;
602 fPainter = nullptr;
603 fEntries = 0;
604 fNormFactor = 0;
606 fMaximum = -1111;
607 fMinimum = -1111;
608 fBufferSize = 0;
609 fBuffer = nullptr;
611 fStatOverflows = EStatOverflows::kNeutral;
612 fXaxis.SetName("xaxis");
613 fYaxis.SetName("yaxis");
614 fZaxis.SetName("zaxis");
615 fXaxis.SetParent(this);
616 fYaxis.SetParent(this);
617 fZaxis.SetParent(this);
619}
620
621////////////////////////////////////////////////////////////////////////////////
622/// Histogram default destructor.
623
625{
627 return;
628 }
629 delete[] fIntegral;
630 fIntegral = nullptr;
631 delete[] fBuffer;
632 fBuffer = nullptr;
633 if (fFunctions) {
635
637 TObject* obj = nullptr;
638 //special logic to support the case where the same object is
639 //added multiple times in fFunctions.
640 //This case happens when the same object is added with different
641 //drawing modes
642 //In the loop below we must be careful with objects (eg TCutG) that may
643 // have been added to the list of functions of several histograms
644 //and may have been already deleted.
645 while ((obj = fFunctions->First())) {
646 while(fFunctions->Remove(obj)) { }
648 break;
649 }
650 delete obj;
651 obj = nullptr;
652 }
653 delete fFunctions;
654 fFunctions = nullptr;
655 }
656 if (fDirectory) {
657 fDirectory->Remove(this);
658 fDirectory = nullptr;
659 }
660 delete fPainter;
661 fPainter = nullptr;
662}
663
664////////////////////////////////////////////////////////////////////////////////
665/// Constructor for fix bin size histograms.
666/// Creates the main histogram structure.
667///
668/// \param[in] name name of histogram (avoid blanks)
669/// \param[in] title histogram title.
670/// If title is of the form `stringt;stringx;stringy;stringz`,
671/// the histogram title is set to `stringt`,
672/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
673/// \param[in] nbins number of bins
674/// \param[in] xlow low edge of first bin
675/// \param[in] xup upper edge of last bin (not included in last bin)
676
677
678TH1::TH1(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
679 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
680{
681 Build();
682 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
683 fXaxis.Set(nbins,xlow,xup);
684 fNcells = fXaxis.GetNbins()+2;
685}
686
687////////////////////////////////////////////////////////////////////////////////
688/// Constructor for variable bin size histograms using an input array of type float.
689/// Creates the main histogram structure.
690///
691/// \param[in] name name of histogram (avoid blanks)
692/// \param[in] title histogram title.
693/// If title is of the form `stringt;stringx;stringy;stringz`
694/// the histogram title is set to `stringt`,
695/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
696/// \param[in] nbins number of bins
697/// \param[in] xbins array of low-edges for each bin.
698/// This is an array of type float and size nbins+1
699
700TH1::TH1(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
701 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
702{
703 Build();
704 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
705 if (xbins) fXaxis.Set(nbins,xbins);
706 else fXaxis.Set(nbins,0,1);
707 fNcells = fXaxis.GetNbins()+2;
708}
709
710////////////////////////////////////////////////////////////////////////////////
711/// Constructor for variable bin size histograms using an input array of type double.
712///
713/// \param[in] name name of histogram (avoid blanks)
714/// \param[in] title histogram title.
715/// If title is of the form `stringt;stringx;stringy;stringz`
716/// the histogram title is set to `stringt`,
717/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
718/// \param[in] nbins number of bins
719/// \param[in] xbins array of low-edges for each bin.
720/// This is an array of type double and size nbins+1
721
722TH1::TH1(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
723 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
724{
725 Build();
726 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
727 if (xbins) fXaxis.Set(nbins,xbins);
728 else fXaxis.Set(nbins,0,1);
729 fNcells = fXaxis.GetNbins()+2;
730}
731
732////////////////////////////////////////////////////////////////////////////////
733/// Static function: cannot be inlined on Windows/NT.
734
736{
737 return fgAddDirectory;
738}
739
740////////////////////////////////////////////////////////////////////////////////
741/// Browse the Histogram object.
742
744{
745 Draw(b ? b->GetDrawOption() : "");
746 gPad->Update();
747}
748
749////////////////////////////////////////////////////////////////////////////////
750/// Creates histogram basic data structure.
751
753{
754 fDirectory = nullptr;
755 fPainter = nullptr;
756 fIntegral = nullptr;
757 fEntries = 0;
758 fNormFactor = 0;
760 fMaximum = -1111;
761 fMinimum = -1111;
762 fBufferSize = 0;
763 fBuffer = nullptr;
765 fStatOverflows = EStatOverflows::kNeutral;
766 fXaxis.SetName("xaxis");
767 fYaxis.SetName("yaxis");
768 fZaxis.SetName("zaxis");
769 fYaxis.Set(1,0.,1.);
770 fZaxis.Set(1,0.,1.);
771 fXaxis.SetParent(this);
772 fYaxis.SetParent(this);
773 fZaxis.SetParent(this);
774
776
777 fFunctions = new TList;
778
780
783 if (fDirectory) {
785 fDirectory->Append(this,kTRUE);
786 }
787 }
788}
789
790////////////////////////////////////////////////////////////////////////////////
791/// Performs the operation: `this = this + c1*f1`
792/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
793///
794/// By default, the function is computed at the centre of the bin.
795/// if option "I" is specified (1-d histogram only), the integral of the
796/// function in each bin is used instead of the value of the function at
797/// the centre of the bin.
798///
799/// Only bins inside the function range are recomputed.
800///
801/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
802/// you should call Sumw2 before making this operation.
803/// This is particularly important if you fit the histogram after TH1::Add
804///
805/// The function return kFALSE if the Add operation failed
806
808{
809 if (!f1) {
810 Error("Add","Attempt to add a non-existing function");
811 return kFALSE;
812 }
813
814 TString opt = option;
815 opt.ToLower();
816 Bool_t integral = kFALSE;
817 if (opt.Contains("i") && fDimension == 1) integral = kTRUE;
818
819 Int_t ncellsx = GetNbinsX() + 2; // cells = normal bins + underflow bin + overflow bin
820 Int_t ncellsy = GetNbinsY() + 2;
821 Int_t ncellsz = GetNbinsZ() + 2;
822 if (fDimension < 2) ncellsy = 1;
823 if (fDimension < 3) ncellsz = 1;
824
825 // delete buffer if it is there since it will become invalid
826 if (fBuffer) BufferEmpty(1);
827
828 // - Add statistics
829 Double_t s1[10];
830 for (Int_t i = 0; i < 10; ++i) s1[i] = 0;
831 PutStats(s1);
832 SetMinimum();
833 SetMaximum();
834
835 // - Loop on bins (including underflows/overflows)
836 Int_t bin, binx, biny, binz;
837 Double_t cu=0;
838 Double_t xx[3];
839 Double_t *params = 0;
840 f1->InitArgs(xx,params);
841 for (binz = 0; binz < ncellsz; ++binz) {
842 xx[2] = fZaxis.GetBinCenter(binz);
843 for (biny = 0; biny < ncellsy; ++biny) {
844 xx[1] = fYaxis.GetBinCenter(biny);
845 for (binx = 0; binx < ncellsx; ++binx) {
846 xx[0] = fXaxis.GetBinCenter(binx);
847 if (!f1->IsInside(xx)) continue;
849 bin = binx + ncellsx * (biny + ncellsy * binz);
850 if (integral) {
851 cu = c1*f1->Integral(fXaxis.GetBinLowEdge(binx), fXaxis.GetBinUpEdge(binx), 0.) / fXaxis.GetBinWidth(binx);
852 } else {
853 cu = c1*f1->EvalPar(xx);
854 }
855 if (TF1::RejectedPoint()) continue;
856 AddBinContent(bin,cu);
857 }
858 }
859 }
860
861 return kTRUE;
862}
863
864////////////////////////////////////////////////////////////////////////////////
865/// Performs the operation: `this = this + c1*h1`
866/// If errors are defined (see TH1::Sumw2), errors are also recalculated.
867///
868/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
869/// if not already set.
870///
871/// Note also that adding histogram with labels is not supported, histogram will be
872/// added merging them by bin number independently of the labels.
873/// For adding histogram with labels one should use TH1::Merge
874///
875/// SPECIAL CASE (Average/Efficiency histograms)
876/// For histograms representing averages or efficiencies, one should compute the average
877/// of the two histograms and not the sum. One can mark a histogram to be an average
878/// histogram by setting its bit kIsAverage with
879/// myhist.SetBit(TH1::kIsAverage);
880/// Note that the two histograms must have their kIsAverage bit set
881///
882/// IMPORTANT NOTE1: If you intend to use the errors of this histogram later
883/// you should call Sumw2 before making this operation.
884/// This is particularly important if you fit the histogram after TH1::Add
885///
886/// IMPORTANT NOTE2: if h1 has a normalisation factor, the normalisation factor
887/// is used , ie this = this + c1*factor*h1
888/// Use the other TH1::Add function if you do not want this feature
889///
890/// IMPORTANT NOTE3: You should be careful about the statistics of the
891/// returned histogram, whose statistics may be binned or unbinned,
892/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
893/// and whether TH1::ResetStats has been called on either this or h1.
894/// See TH1::GetStats.
895///
896/// The function return kFALSE if the Add operation failed
897
899{
900 if (!h1) {
901 Error("Add","Attempt to add a non-existing histogram");
902 return kFALSE;
903 }
904
905 // delete buffer if it is there since it will become invalid
906 if (fBuffer) BufferEmpty(1);
907
908 bool useMerge = (c1 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
909 try {
910 CheckConsistency(this,h1);
911 useMerge = kFALSE;
912 } catch(DifferentNumberOfBins&) {
913 if (useMerge)
914 Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
915 else {
916 Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 = %d",GetNbinsX(), h1->GetNbinsX());
917 return kFALSE;
918 }
919 } catch(DifferentAxisLimits&) {
920 if (useMerge)
921 Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
922 else
923 Warning("Add","Attempt to add histograms with different axis limits");
924 } catch(DifferentBinLimits&) {
925 if (useMerge)
926 Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
927 else
928 Warning("Add","Attempt to add histograms with different bin limits");
929 } catch(DifferentLabels&) {
930 // in case of different labels -
931 if (useMerge)
932 Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
933 else
934 Info("Warning","Attempt to add histograms with different labels");
935 }
936
937 if (useMerge) {
938 TList l;
939 l.Add(const_cast<TH1*>(h1));
940 auto iret = Merge(&l);
941 return (iret >= 0);
942 }
943
944 // Create Sumw2 if h1 has Sumw2 set
945 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
946
947 // - Add statistics
948 Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() );
949
950 // statistics can be preserved only in case of positive coefficients
951 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
952 Bool_t resetStats = (c1 < 0);
953 Double_t s1[kNstat] = {0};
954 Double_t s2[kNstat] = {0};
955 if (!resetStats) {
956 // need to initialize to zero s1 and s2 since
957 // GetStats fills only used elements depending on dimension and type
958 GetStats(s1);
959 h1->GetStats(s2);
960 }
961
962 SetMinimum();
963 SetMaximum();
964
965 // - Loop on bins (including underflows/overflows)
966 Double_t factor = 1;
967 if (h1->GetNormFactor() != 0) factor = h1->GetNormFactor()/h1->GetSumOfWeights();;
968 Double_t c1sq = c1 * c1;
969 Double_t factsq = factor * factor;
970
971 for (Int_t bin = 0; bin < fNcells; ++bin) {
972 //special case where histograms have the kIsAverage bit set
973 if (this->TestBit(kIsAverage) && h1->TestBit(kIsAverage)) {
975 Double_t y2 = this->RetrieveBinContent(bin);
977 Double_t e2sq = this->GetBinErrorSqUnchecked(bin);
978 Double_t w1 = 1., w2 = 1.;
979
980 // consider all special cases when bin errors are zero
981 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
982 if (e1sq) w1 = 1. / e1sq;
983 else if (h1->fSumw2.fN) {
984 w1 = 1.E200; // use an arbitrary huge value
985 if (y1 == 0) {
986 // use an estimated error from the global histogram scale
987 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
988 w1 = 1./(sf*sf);
989 }
990 }
991 if (e2sq) w2 = 1. / e2sq;
992 else if (fSumw2.fN) {
993 w2 = 1.E200; // use an arbitrary huge value
994 if (y2 == 0) {
995 // use an estimated error from the global histogram scale
996 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
997 w2 = 1./(sf*sf);
998 }
999 }
1000
1001 double y = (w1*y1 + w2*y2)/(w1 + w2);
1002 UpdateBinContent(bin, y);
1003 if (fSumw2.fN) {
1004 double err2 = 1./(w1 + w2);
1005 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1006 fSumw2.fArray[bin] = err2;
1007 }
1008 } else { // normal case of addition between histograms
1009 AddBinContent(bin, c1 * factor * h1->RetrieveBinContent(bin));
1010 if (fSumw2.fN) fSumw2.fArray[bin] += c1sq * factsq * h1->GetBinErrorSqUnchecked(bin);
1011 }
1012 }
1013
1014 // update statistics (do here to avoid changes by SetBinContent)
1015 if (resetStats) {
1016 // statistics need to be reset in case coefficient are negative
1017 ResetStats();
1018 }
1019 else {
1020 for (Int_t i=0;i<kNstat;i++) {
1021 if (i == 1) s1[i] += c1*c1*s2[i];
1022 else s1[i] += c1*s2[i];
1023 }
1024 PutStats(s1);
1025 SetEntries(entries);
1026 }
1027 return kTRUE;
1028}
1029
1030////////////////////////////////////////////////////////////////////////////////
1031/// Replace contents of this histogram by the addition of h1 and h2.
1032///
1033/// `this = c1*h1 + c2*h2`
1034/// if errors are defined (see TH1::Sumw2), errors are also recalculated
1035///
1036/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
1037/// if not already set.
1038///
1039/// Note also that adding histogram with labels is not supported, histogram will be
1040/// added merging them by bin number independently of the labels.
1041/// For adding histogram ith labels one should use TH1::Merge
1042///
1043/// SPECIAL CASE (Average/Efficiency histograms)
1044/// For histograms representing averages or efficiencies, one should compute the average
1045/// of the two histograms and not the sum. One can mark a histogram to be an average
1046/// histogram by setting its bit kIsAverage with
1047/// myhist.SetBit(TH1::kIsAverage);
1048/// Note that the two histograms must have their kIsAverage bit set
1049///
1050/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
1051/// you should call Sumw2 before making this operation.
1052/// This is particularly important if you fit the histogram after TH1::Add
1053///
1054/// IMPORTANT NOTE2: You should be careful about the statistics of the
1055/// returned histogram, whose statistics may be binned or unbinned,
1056/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
1057/// and whether TH1::ResetStats has been called on either this or h1.
1058/// See TH1::GetStats.
1059///
1060/// ANOTHER SPECIAL CASE : h1 = h2 and c2 < 0
1061/// do a scaling this = c1 * h1 / (bin Volume)
1062///
1063/// The function returns kFALSE if the Add operation failed
1064
1066{
1067
1068 if (!h1 || !h2) {
1069 Error("Add","Attempt to add a non-existing histogram");
1070 return kFALSE;
1071 }
1072
1073 // delete buffer if it is there since it will become invalid
1074 if (fBuffer) BufferEmpty(1);
1075
1076 Bool_t normWidth = kFALSE;
1077 if (h1 == h2 && c2 < 0) {c2 = 0; normWidth = kTRUE;}
1078
1079 if (h1 != h2) {
1080 bool useMerge = (c1 == 1. && c2 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
1081
1082 try {
1083 CheckConsistency(h1,h2);
1084 CheckConsistency(this,h1);
1085 useMerge = kFALSE;
1086 } catch(DifferentNumberOfBins&) {
1087 if (useMerge)
1088 Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
1089 else {
1090 Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 = %d",GetNbinsX(), h1->GetNbinsX());
1091 return kFALSE;
1092 }
1093 } catch(DifferentAxisLimits&) {
1094 if (useMerge)
1095 Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
1096 else
1097 Warning("Add","Attempt to add histograms with different axis limits");
1098 } catch(DifferentBinLimits&) {
1099 if (useMerge)
1100 Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
1101 else
1102 Warning("Add","Attempt to add histograms with different bin limits");
1103 } catch(DifferentLabels&) {
1104 // in case of different labels -
1105 if (useMerge)
1106 Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
1107 else
1108 Info("Warning","Attempt to add histograms with different labels");
1109 }
1110
1111 if (useMerge) {
1112 TList l;
1113 // why TList takes non-const pointers ????
1114 l.Add(const_cast<TH1*>(h1));
1115 l.Add(const_cast<TH1*>(h2));
1116 Reset("ICE");
1117 auto iret = Merge(&l);
1118 return (iret >= 0);
1119 }
1120 }
1121
1122 // Create Sumw2 if h1 or h2 have Sumw2 set
1123 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();
1124
1125 // - Add statistics
1126 Double_t nEntries = TMath::Abs( c1*h1->GetEntries() + c2*h2->GetEntries() );
1127
1128 // TODO remove
1129 // statistics can be preserved only in case of positive coefficients
1130 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
1131 // also in case of scaling with the width we cannot preserve the statistics
1132 Double_t s1[kNstat] = {0};
1133 Double_t s2[kNstat] = {0};
1134 Double_t s3[kNstat];
1135
1136
1137 Bool_t resetStats = (c1*c2 < 0) || normWidth;
1138 if (!resetStats) {
1139 // need to initialize to zero s1 and s2 since
1140 // GetStats fills only used elements depending on dimension and type
1141 h1->GetStats(s1);
1142 h2->GetStats(s2);
1143 for (Int_t i=0;i<kNstat;i++) {
1144 if (i == 1) s3[i] = c1*c1*s1[i] + c2*c2*s2[i];
1145 //else s3[i] = TMath::Abs(c1)*s1[i] + TMath::Abs(c2)*s2[i];
1146 else s3[i] = c1*s1[i] + c2*s2[i];
1147 }
1148 }
1149
1150 SetMinimum();
1151 SetMaximum();
1152
1153 if (normWidth) { // DEPRECATED CASE: belongs to fitting / drawing modules
1154
1155 Int_t nbinsx = GetNbinsX() + 2; // normal bins + underflow, overflow
1156 Int_t nbinsy = GetNbinsY() + 2;
1157 Int_t nbinsz = GetNbinsZ() + 2;
1158
1159 if (fDimension < 2) nbinsy = 1;
1160 if (fDimension < 3) nbinsz = 1;
1161
1162 Int_t bin, binx, biny, binz;
1163 for (binz = 0; binz < nbinsz; ++binz) {
1164 Double_t wz = h1->GetZaxis()->GetBinWidth(binz);
1165 for (biny = 0; biny < nbinsy; ++biny) {
1166 Double_t wy = h1->GetYaxis()->GetBinWidth(biny);
1167 for (binx = 0; binx < nbinsx; ++binx) {
1168 Double_t wx = h1->GetXaxis()->GetBinWidth(binx);
1169 bin = GetBin(binx, biny, binz);
1170 Double_t w = wx*wy*wz;
1171 UpdateBinContent(bin, c1 * h1->RetrieveBinContent(bin) / w);
1172 if (fSumw2.fN) {
1173 Double_t e1 = h1->GetBinError(bin)/w;
1174 fSumw2.fArray[bin] = c1*c1*e1*e1;
1175 }
1176 }
1177 }
1178 }
1179 } else if (h1->TestBit(kIsAverage) && h2->TestBit(kIsAverage)) {
1180 for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
1181 // special case where histograms have the kIsAverage bit set
1185 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
1186 Double_t w1 = 1., w2 = 1.;
1187
1188 // consider all special cases when bin errors are zero
1189 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
1190 if (e1sq) w1 = 1./ e1sq;
1191 else if (h1->fSumw2.fN) {
1192 w1 = 1.E200; // use an arbitrary huge value
1193 if (y1 == 0 ) { // use an estimated error from the global histogram scale
1194 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
1195 w1 = 1./(sf*sf);
1196 }
1197 }
1198 if (e2sq) w2 = 1./ e2sq;
1199 else if (h2->fSumw2.fN) {
1200 w2 = 1.E200; // use an arbitrary huge value
1201 if (y2 == 0) { // use an estimated error from the global histogram scale
1202 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
1203 w2 = 1./(sf*sf);
1204 }
1205 }
1206
1207 double y = (w1*y1 + w2*y2)/(w1 + w2);
1208 UpdateBinContent(i, y);
1209 if (fSumw2.fN) {
1210 double err2 = 1./(w1 + w2);
1211 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1212 fSumw2.fArray[i] = err2;
1213 }
1214 }
1215 } else { // case of simple histogram addition
1216 Double_t c1sq = c1 * c1;
1217 Double_t c2sq = c2 * c2;
1218 for (Int_t i = 0; i < fNcells; ++i) { // Loop on cells (bins including underflows/overflows)
1220 if (fSumw2.fN) {
1221 fSumw2.fArray[i] = c1sq * h1->GetBinErrorSqUnchecked(i) + c2sq * h2->GetBinErrorSqUnchecked(i);
1222 }
1223 }
1224 }
1225
1226 if (resetStats) {
1227 // statistics need to be reset in case coefficient are negative
1228 ResetStats();
1229 }
1230 else {
1231 // update statistics (do here to avoid changes by SetBinContent) FIXME remove???
1232 PutStats(s3);
1233 SetEntries(nEntries);
1234 }
1235
1236 return kTRUE;
1237}
1238
1239////////////////////////////////////////////////////////////////////////////////
1240/// Increment bin content by 1.
1241
1243{
1244 AbstractMethod("AddBinContent");
1245}
1246
1247////////////////////////////////////////////////////////////////////////////////
1248/// Increment bin content by a weight w.
1249
1251{
1252 AbstractMethod("AddBinContent");
1253}
1254
1255////////////////////////////////////////////////////////////////////////////////
1256/// Sets the flag controlling the automatic add of histograms in memory
1257///
1258/// By default (fAddDirectory = kTRUE), histograms are automatically added
1259/// to the list of objects in memory.
1260/// Note that one histogram can be removed from its support directory
1261/// by calling h->SetDirectory(nullptr) or h->SetDirectory(dir) to add it
1262/// to the list of objects in the directory dir.
1263///
1264/// NOTE that this is a static function. To call it, use;
1265/// TH1::AddDirectory
1266
1268{
1269 fgAddDirectory = add;
1270}
1271
1272////////////////////////////////////////////////////////////////////////////////
1273/// Auxiliary function to get the power of 2 next (larger) or previous (smaller)
1274/// a given x
1275///
1276/// next = kTRUE : next larger
1277/// next = kFALSE : previous smaller
1278///
1279/// Used by the autobin power of 2 algorithm
1280
1282{
1283 Int_t nn;
1284 Double_t f2 = std::frexp(x, &nn);
1285 return ((next && x > 0.) || (!next && x <= 0.)) ? std::ldexp(std::copysign(1., f2), nn)
1286 : std::ldexp(std::copysign(1., f2), --nn);
1287}
1288
1289////////////////////////////////////////////////////////////////////////////////
1290/// Auxiliary function to get the next power of 2 integer value larger then n
1291///
1292/// Used by the autobin power of 2 algorithm
1293
1295{
1296 Int_t nn;
1297 Double_t f2 = std::frexp(n, &nn);
1298 if (TMath::Abs(f2 - .5) > 0.001)
1299 return (Int_t)std::ldexp(1., nn);
1300 return n;
1301}
1302
1303////////////////////////////////////////////////////////////////////////////////
1304/// Buffer-based estimate of the histogram range using the power of 2 algorithm.
1305///
1306/// Used by the autobin power of 2 algorithm.
1307///
1308/// Works on arguments (min and max from fBuffer) and internal inputs: fXmin,
1309/// fXmax, NBinsX (from fXaxis), ...
1310/// Result save internally in fXaxis.
1311///
1312/// Overloaded by TH2 and TH3.
1313///
1314/// Return -1 if internal inputs are inconsistent, 0 otherwise.
1315
1317{
1318 // We need meaningful raw limits
1319 if (xmi >= xma)
1320 return -1;
1321
1323 Double_t xhmi = fXaxis.GetXmin();
1324 Double_t xhma = fXaxis.GetXmax();
1325
1326 // Now adjust
1327 if (TMath::Abs(xhma) > TMath::Abs(xhmi)) {
1328 // Start from the upper limit
1329 xhma = TH1::AutoP2GetPower2(xhma);
1330 xhmi = xhma - TH1::AutoP2GetPower2(xhma - xhmi);
1331 } else {
1332 // Start from the lower limit
1333 xhmi = TH1::AutoP2GetPower2(xhmi, kFALSE);
1334 xhma = xhmi + TH1::AutoP2GetPower2(xhma - xhmi);
1335 }
1336
1337 // Round the bins to the next power of 2; take into account the possible inflation
1338 // of the range
1339 Double_t rr = (xhma - xhmi) / (xma - xmi);
1340 Int_t nb = TH1::AutoP2GetBins((Int_t)(rr * GetNbinsX()));
1341
1342 // Adjust using the same bin width and offsets
1343 Double_t bw = (xhma - xhmi) / nb;
1344 // Bins to left free on each side
1345 Double_t autoside = gEnv->GetValue("Hist.Binning.Auto.Side", 0.05);
1346 Int_t nbside = (Int_t)(nb * autoside);
1347
1348 // Side up
1349 Int_t nbup = (xhma - xma) / bw;
1350 if (nbup % 2 != 0)
1351 nbup++; // Must be even
1352 if (nbup != nbside) {
1353 // Accounts also for both case: larger or smaller
1354 xhma -= bw * (nbup - nbside);
1355 nb -= (nbup - nbside);
1356 }
1357
1358 // Side low
1359 Int_t nblw = (xmi - xhmi) / bw;
1360 if (nblw % 2 != 0)
1361 nblw++; // Must be even
1362 if (nblw != nbside) {
1363 // Accounts also for both case: larger or smaller
1364 xhmi += bw * (nblw - nbside);
1365 nb -= (nblw - nbside);
1366 }
1367
1368 // Set everything and project
1369 SetBins(nb, xhmi, xhma);
1370
1371 // Done
1372 return 0;
1373}
1374
1375/// Fill histogram with all entries in the buffer.
1376///
1377/// - action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
1378/// - action = 0 histogram is reset and filled from the buffer. When the histogram is filled from the
1379/// buffer the value fBuffer[0] is set to a negative number (= - number of entries)
1380/// When calling with action == 0 the histogram is NOT refilled when fBuffer[0] is < 0
1381/// While when calling with action = -1 the histogram is reset and ALWAYS refilled independently if
1382/// the histogram was filled before. This is needed when drawing the histogram
1383/// - action = 1 histogram is filled and buffer is deleted
1384/// The buffer is automatically deleted when filling the histogram and the entries is
1385/// larger than the buffer size
1386
1388{
1389 // do we need to compute the bin size?
1390 if (!fBuffer) return 0;
1391 Int_t nbentries = (Int_t)fBuffer[0];
1392
1393 // nbentries correspond to the number of entries of histogram
1394
1395 if (nbentries == 0) {
1396 // if action is 1 we delete the buffer
1397 // this will avoid infinite recursion
1398 if (action > 0) {
1399 delete [] fBuffer;
1400 fBuffer = nullptr;
1401 fBufferSize = 0;
1402 }
1403 return 0;
1404 }
1405 if (nbentries < 0 && action == 0) return 0; // case histogram has been already filled from the buffer
1406
1407 Double_t *buffer = fBuffer;
1408 if (nbentries < 0) {
1409 nbentries = -nbentries;
1410 // a reset might call BufferEmpty() giving an infinite recursion
1411 // Protect it by setting fBuffer = nullptr
1412 fBuffer = nullptr;
1413 //do not reset the list of functions
1414 Reset("ICES");
1415 fBuffer = buffer;
1416 }
1417 if (CanExtendAllAxes() || (fXaxis.GetXmax() <= fXaxis.GetXmin())) {
1418 //find min, max of entries in buffer
1421 for (Int_t i=0;i<nbentries;i++) {
1422 Double_t x = fBuffer[2*i+2];
1423 // skip infinity or NaN values
1424 if (!std::isfinite(x)) continue;
1425 if (x < xmin) xmin = x;
1426 if (x > xmax) xmax = x;
1427 }
1428 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
1429 Int_t rc = -1;
1431 if ((rc = AutoP2FindLimits(xmin, xmax)) < 0)
1432 Warning("BufferEmpty",
1433 "inconsistency found by power-of-2 autobin algorithm: fallback to standard method");
1434 }
1435 if (rc < 0)
1437 } else {
1438 fBuffer = nullptr;
1439 Int_t keep = fBufferSize; fBufferSize = 0;
1441 if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax, &fXaxis);
1442 fBuffer = buffer;
1443 fBufferSize = keep;
1444 }
1445 }
1446
1447 // call DoFillN which will not put entries in the buffer as FillN does
1448 // set fBuffer to zero to avoid re-emptying the buffer from functions called
1449 // by DoFillN (e.g Sumw2)
1450 buffer = fBuffer; fBuffer = nullptr;
1451 DoFillN(nbentries,&buffer[2],&buffer[1],2);
1452 fBuffer = buffer;
1453
1454 // if action == 1 - delete the buffer
1455 if (action > 0) {
1456 delete [] fBuffer;
1457 fBuffer = nullptr;
1458 fBufferSize = 0;
1459 } else {
1460 // if number of entries is consistent with buffer - set it negative to avoid
1461 // refilling the histogram every time BufferEmpty(0) is called
1462 // In case it is not consistent, by setting fBuffer[0]=0 is like resetting the buffer
1463 // (it will not be used anymore the next time BufferEmpty is called)
1464 if (nbentries == (Int_t)fEntries)
1465 fBuffer[0] = -nbentries;
1466 else
1467 fBuffer[0] = 0;
1468 }
1469 return nbentries;
1470}
1471
1472////////////////////////////////////////////////////////////////////////////////
1473/// accumulate arguments in buffer. When buffer is full, empty the buffer
1474///
1475/// - `fBuffer[0]` = number of entries in buffer
1476/// - `fBuffer[1]` = w of first entry
1477/// - `fBuffer[2]` = x of first entry
1478
1480{
1481 if (!fBuffer) return -2;
1482 Int_t nbentries = (Int_t)fBuffer[0];
1483
1484
1485 if (nbentries < 0) {
1486 // reset nbentries to a positive value so next time BufferEmpty() is called
1487 // the histogram will be refilled
1488 nbentries = -nbentries;
1489 fBuffer[0] = nbentries;
1490 if (fEntries > 0) {
1491 // set fBuffer to zero to avoid calling BufferEmpty in Reset
1492 Double_t *buffer = fBuffer; fBuffer=0;
1493 Reset("ICES"); // do not reset list of functions
1494 fBuffer = buffer;
1495 }
1496 }
1497 if (2*nbentries+2 >= fBufferSize) {
1498 BufferEmpty(1);
1499 if (!fBuffer)
1500 // to avoid infinite recursion Fill->BufferFill->Fill
1501 return Fill(x,w);
1502 // this cannot happen
1503 R__ASSERT(0);
1504 }
1505 fBuffer[2*nbentries+1] = w;
1506 fBuffer[2*nbentries+2] = x;
1507 fBuffer[0] += 1;
1508 return -2;
1509}
1510
1511////////////////////////////////////////////////////////////////////////////////
1512/// Check bin limits.
1513
1514bool TH1::CheckBinLimits(const TAxis* a1, const TAxis * a2)
1515{
1516 const TArrayD * h1Array = a1->GetXbins();
1517 const TArrayD * h2Array = a2->GetXbins();
1518 Int_t fN = h1Array->fN;
1519 if ( fN != 0 ) {
1520 if ( h2Array->fN != fN ) {
1521 throw DifferentBinLimits();
1522 return false;
1523 }
1524 else {
1525 for ( int i = 0; i < fN; ++i ) {
1526 // for i==fN (nbin+1) a->GetBinWidth() returns last bin width
1527 // we do not need to exclude that case
1528 double binWidth = a1->GetBinWidth(i);
1529 if ( ! TMath::AreEqualAbs( h1Array->GetAt(i), h2Array->GetAt(i), binWidth*1E-10 ) ) {
1530 throw DifferentBinLimits();
1531 return false;
1532 }
1533 }
1534 }
1535 }
1536
1537 return true;
1538}
1539
1540////////////////////////////////////////////////////////////////////////////////
1541/// Check that axis have same labels.
1542
1543bool TH1::CheckBinLabels(const TAxis* a1, const TAxis * a2)
1544{
1545 THashList *l1 = a1->GetLabels();
1546 THashList *l2 = a2->GetLabels();
1547
1548 if (!l1 && !l2 )
1549 return true;
1550 if (!l1 || !l2 ) {
1551 throw DifferentLabels();
1552 return false;
1553 }
1554 // check now labels sizes are the same
1555 if (l1->GetSize() != l2->GetSize() ) {
1556 throw DifferentLabels();
1557 return false;
1558 }
1559 for (int i = 1; i <= a1->GetNbins(); ++i) {
1560 TString label1 = a1->GetBinLabel(i);
1561 TString label2 = a2->GetBinLabel(i);
1562 if (label1 != label2) {
1563 throw DifferentLabels();
1564 return false;
1565 }
1566 }
1567
1568 return true;
1569}
1570
1571////////////////////////////////////////////////////////////////////////////////
1572/// Check that the axis limits of the histograms are the same.
1573/// If a first and last bin is passed the axis is compared between the given range
1574
1575bool TH1::CheckAxisLimits(const TAxis *a1, const TAxis *a2 )
1576{
1577 double firstBin = a1->GetBinWidth(1);
1578 double lastBin = a1->GetBinWidth( a1->GetNbins() );
1579 if ( ! TMath::AreEqualAbs(a1->GetXmin(), a2->GetXmin(), firstBin* 1.E-10) ||
1580 ! TMath::AreEqualAbs(a1->GetXmax(), a2->GetXmax(), lastBin*1.E-10) ) {
1581 throw DifferentAxisLimits();
1582 return false;
1583 }
1584 return true;
1585}
1586
1587////////////////////////////////////////////////////////////////////////////////
1588/// Check that the axis are the same
1589
1590bool TH1::CheckEqualAxes(const TAxis *a1, const TAxis *a2 )
1591{
1592 if (a1->GetNbins() != a2->GetNbins() ) {
1593 //throw DifferentNumberOfBins();
1594 ::Info("CheckEqualAxes","Axes have different number of bins : nbin1 = %d nbin2 = %d",a1->GetNbins(),a2->GetNbins() );
1595 return false;
1596 }
1597 try {
1598 CheckAxisLimits(a1,a2);
1599 } catch (DifferentAxisLimits&) {
1600 ::Info("CheckEqualAxes","Axes have different limits");
1601 return false;
1602 }
1603 try {
1604 CheckBinLimits(a1,a2);
1605 } catch (DifferentBinLimits&) {
1606 ::Info("CheckEqualAxes","Axes have different bin limits");
1607 return false;
1608 }
1609
1610 // check labels
1611 try {
1612 CheckBinLabels(a1,a2);
1613 } catch (DifferentLabels&) {
1614 ::Info("CheckEqualAxes","Axes have different labels");
1615 return false;
1616 }
1617
1618 return true;
1619}
1620
1621////////////////////////////////////////////////////////////////////////////////
1622/// Check that two sub axis are the same.
1623/// The limits are defined by first bin and last bin
1624/// N.B. no check is done in this case for variable bins
1625
1626bool TH1::CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis * a2, Int_t firstBin2, Int_t lastBin2 )
1627{
1628 // By default is assumed that no bins are given for the second axis
1629 Int_t nbins1 = lastBin1-firstBin1 + 1;
1630 Double_t xmin1 = a1->GetBinLowEdge(firstBin1);
1631 Double_t xmax1 = a1->GetBinUpEdge(lastBin1);
1632
1633 Int_t nbins2 = a2->GetNbins();
1634 Double_t xmin2 = a2->GetXmin();
1635 Double_t xmax2 = a2->GetXmax();
1636
1637 if (firstBin2 < lastBin2) {
1638 // in this case assume no bins are given for the second axis
1639 nbins2 = lastBin1-firstBin1 + 1;
1640 xmin2 = a1->GetBinLowEdge(firstBin1);
1641 xmax2 = a1->GetBinUpEdge(lastBin1);
1642 }
1643
1644 if (nbins1 != nbins2 ) {
1645 ::Info("CheckConsistentSubAxes","Axes have different number of bins");
1646 return false;
1647 }
1648
1649 Double_t firstBin = a1->GetBinWidth(firstBin1);
1650 Double_t lastBin = a1->GetBinWidth(lastBin1);
1651 if ( ! TMath::AreEqualAbs(xmin1,xmin2,1.E-10 * firstBin) ||
1652 ! TMath::AreEqualAbs(xmax1,xmax2,1.E-10 * lastBin) ) {
1653 ::Info("CheckConsistentSubAxes","Axes have different limits");
1654 return false;
1655 }
1656
1657 return true;
1658}
1659
1660////////////////////////////////////////////////////////////////////////////////
1661/// Check histogram compatibility.
1662
1663bool TH1::CheckConsistency(const TH1* h1, const TH1* h2)
1664{
1665 if (h1 == h2) return true;
1666
1667 if (h1->GetDimension() != h2->GetDimension() ) {
1668 throw DifferentDimension();
1669 return false;
1670 }
1671 Int_t dim = h1->GetDimension();
1672
1673 // returns kTRUE if number of bins and bin limits are identical
1674 Int_t nbinsx = h1->GetNbinsX();
1675 Int_t nbinsy = h1->GetNbinsY();
1676 Int_t nbinsz = h1->GetNbinsZ();
1677
1678 // Check whether the histograms have the same number of bins.
1679 if (nbinsx != h2->GetNbinsX() ||
1680 (dim > 1 && nbinsy != h2->GetNbinsY()) ||
1681 (dim > 2 && nbinsz != h2->GetNbinsZ()) ) {
1682 throw DifferentNumberOfBins();
1683 return false;
1684 }
1685
1686 bool ret = true;
1687
1688 // check axis limits
1689 ret &= CheckAxisLimits(h1->GetXaxis(), h2->GetXaxis());
1690 if (dim > 1) ret &= CheckAxisLimits(h1->GetYaxis(), h2->GetYaxis());
1691 if (dim > 2) ret &= CheckAxisLimits(h1->GetZaxis(), h2->GetZaxis());
1692
1693 // check bin limits
1694 ret &= CheckBinLimits(h1->GetXaxis(), h2->GetXaxis());
1695 if (dim > 1) ret &= CheckBinLimits(h1->GetYaxis(), h2->GetYaxis());
1696 if (dim > 2) ret &= CheckBinLimits(h1->GetZaxis(), h2->GetZaxis());
1697
1698 // check labels if histograms are both not empty
1699 if ( !h1->IsEmpty() && !h2->IsEmpty() ) {
1700 ret &= CheckBinLabels(h1->GetXaxis(), h2->GetXaxis());
1701 if (dim > 1) ret &= CheckBinLabels(h1->GetYaxis(), h2->GetYaxis());
1702 if (dim > 2) ret &= CheckBinLabels(h1->GetZaxis(), h2->GetZaxis());
1703 }
1704
1705 return ret;
1706}
1707
1708////////////////////////////////////////////////////////////////////////////////
1709/// \f$ \chi^{2} \f$ test for comparing weighted and unweighted histograms
1710///
1711/// Function: Returns p-value. Other return values are specified by the 3rd parameter
1712///
1713/// \param[in] h2 the second histogram
1714/// \param[in] option
1715/// - "UU" = experiment experiment comparison (unweighted-unweighted)
1716/// - "UW" = experiment MC comparison (unweighted-weighted). Note that
1717/// the first histogram should be unweighted
1718/// - "WW" = MC MC comparison (weighted-weighted)
1719/// - "NORM" = to be used when one or both of the histograms is scaled
1720/// but the histogram originally was unweighted
1721/// - by default underflows and overflows are not included:
1722/// * "OF" = overflows included
1723/// * "UF" = underflows included
1724/// - "P" = print chi2, ndf, p_value, igood
1725/// - "CHI2" = returns chi2 instead of p-value
1726/// - "CHI2/NDF" = returns \f$ \chi^{2} \f$/ndf
1727/// \param[in] res not empty - computes normalized residuals and returns them in this array
1728///
1729/// The current implementation is based on the papers \f$ \chi^{2} \f$ test for comparison
1730/// of weighted and unweighted histograms" in Proceedings of PHYSTAT05 and
1731/// "Comparison weighted and unweighted histograms", arXiv:physics/0605123
1732/// by N.Gagunashvili. This function has been implemented by Daniel Haertl in August 2006.
1733///
1734/// #### Introduction:
1735///
1736/// A frequently used technique in data analysis is the comparison of
1737/// histograms. First suggested by Pearson [1] the \f$ \chi^{2} \f$ test of
1738/// homogeneity is used widely for comparing usual (unweighted) histograms.
1739/// This paper describes the implementation modified \f$ \chi^{2} \f$ tests
1740/// for comparison of weighted and unweighted histograms and two weighted
1741/// histograms [2] as well as usual Pearson's \f$ \chi^{2} \f$ test for
1742/// comparison two usual (unweighted) histograms.
1743///
1744/// #### Overview:
1745///
1746/// Comparison of two histograms expect hypotheses that two histograms
1747/// represent identical distributions. To make a decision p-value should
1748/// be calculated. The hypotheses of identity is rejected if the p-value is
1749/// lower then some significance level. Traditionally significance levels
1750/// 0.1, 0.05 and 0.01 are used. The comparison procedure should include an
1751/// analysis of the residuals which is often helpful in identifying the
1752/// bins of histograms responsible for a significant overall \f$ \chi^{2} \f$ value.
1753/// Residuals are the difference between bin contents and expected bin
1754/// contents. Most convenient for analysis are the normalized residuals. If
1755/// hypotheses of identity are valid then normalized residuals are
1756/// approximately independent and identically distributed random variables
1757/// having N(0,1) distribution. Analysis of residuals expect test of above
1758/// mentioned properties of residuals. Notice that indirectly the analysis
1759/// of residuals increase the power of \f$ \chi^{2} \f$ test.
1760///
1761/// #### Methods of comparison:
1762///
1763/// \f$ \chi^{2} \f$ test for comparison two (unweighted) histograms:
1764/// Let us consider two histograms with the same binning and the number
1765/// of bins equal to r. Let us denote the number of events in the ith bin
1766/// in the first histogram as ni and as mi in the second one. The total
1767/// number of events in the first histogram is equal to:
1768/// \f[
1769/// N = \sum_{i=1}^{r} n_{i}
1770/// \f]
1771/// and
1772/// \f[
1773/// M = \sum_{i=1}^{r} m_{i}
1774/// \f]
1775/// in the second histogram. The hypothesis of identity (homogeneity) [3]
1776/// is that the two histograms represent random values with identical
1777/// distributions. It is equivalent that there exist r constants p1,...,pr,
1778/// such that
1779/// \f[
1780///\sum_{i=1}^{r} p_{i}=1
1781/// \f]
1782/// and the probability of belonging to the ith bin for some measured value
1783/// in both experiments is equal to pi. The number of events in the ith
1784/// bin is a random variable with a distribution approximated by a Poisson
1785/// probability distribution
1786/// \f[
1787///\frac{e^{-Np_{i}}(Np_{i})^{n_{i}}}{n_{i}!}
1788/// \f]
1789///for the first histogram and with distribution
1790/// \f[
1791///\frac{e^{-Mp_{i}}(Mp_{i})^{m_{i}}}{m_{i}!}
1792/// \f]
1793/// for the second histogram. If the hypothesis of homogeneity is valid,
1794/// then the maximum likelihood estimator of pi, i=1,...,r, is
1795/// \f[
1796///\hat{p}_{i}= \frac{n_{i}+m_{i}}{N+M}
1797/// \f]
1798/// and then
1799/// \f[
1800/// 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}}
1801/// \f]
1802/// has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [3].
1803/// The comparison procedure can include an analysis of the residuals which
1804/// is often helpful in identifying the bins of histograms responsible for
1805/// a significant overall \f$ \chi^{2} \f$ value. Most convenient for
1806/// analysis are the adjusted (normalized) residuals [4]
1807/// \f[
1808/// 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))}}
1809/// \f]
1810/// If hypotheses of homogeneity are valid then residuals ri are
1811/// approximately independent and identically distributed random variables
1812/// having N(0,1) distribution. The application of the \f$ \chi^{2} \f$ test has
1813/// restrictions related to the value of the expected frequencies Npi,
1814/// Mpi, i=1,...,r. A conservative rule formulated in [5] is that all the
1815/// expectations must be 1 or greater for both histograms. In practical
1816/// cases when expected frequencies are not known the estimated expected
1817/// frequencies \f$ M\hat{p}_{i}, N\hat{p}_{i}, i=1,...,r \f$ can be used.
1818///
1819/// #### Unweighted and weighted histograms comparison:
1820///
1821/// A simple modification of the ideas described above can be used for the
1822/// comparison of the usual (unweighted) and weighted histograms. Let us
1823/// denote the number of events in the ith bin in the unweighted
1824/// histogram as ni and the common weight of events in the ith bin of the
1825/// weighted histogram as wi. The total number of events in the
1826/// unweighted histogram is equal to
1827///\f[
1828/// N = \sum_{i=1}^{r} n_{i}
1829///\f]
1830/// and the total weight of events in the weighted histogram is equal to
1831///\f[
1832/// W = \sum_{i=1}^{r} w_{i}
1833///\f]
1834/// Let us formulate the hypothesis of identity of an unweighted histogram
1835/// to a weighted histogram so that there exist r constants p1,...,pr, such
1836/// that
1837///\f[
1838/// \sum_{i=1}^{r} p_{i} = 1
1839///\f]
1840/// for the unweighted histogram. The weight wi is a random variable with a
1841/// distribution approximated by the normal probability distribution
1842/// \f$ N(Wp_{i},\sigma_{i}^{2}) \f$ where \f$ \sigma_{i}^{2} \f$ is the variance of the weight wi.
1843/// If we replace the variance \f$ \sigma_{i}^{2} \f$
1844/// with estimate \f$ s_{i}^{2} \f$ (sum of squares of weights of
1845/// events in the ith bin) and the hypothesis of identity is valid, then the
1846/// maximum likelihood estimator of pi,i=1,...,r, is
1847///\f[
1848/// \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}}
1849///\f]
1850/// We may then use the test statistic
1851///\f[
1852/// 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}}
1853///\f]
1854/// and it has approximately a \f$ \sigma^{2}_{(r-1)} \f$ distribution [2]. This test, as well
1855/// as the original one [3], has a restriction on the expected frequencies. The
1856/// expected frequencies recommended for the weighted histogram is more than 25.
1857/// The value of the minimal expected frequency can be decreased down to 10 for
1858/// the case when the weights of the events are close to constant. In the case
1859/// of a weighted histogram if the number of events is unknown, then we can
1860/// apply this recommendation for the equivalent number of events as
1861///\f[
1862/// n_{i}^{equiv} = \frac{ w_{i}^{2} }{ s_{i}^{2} }
1863///\f]
1864/// The minimal expected frequency for an unweighted histogram must be 1. Notice
1865/// that any usual (unweighted) histogram can be considered as a weighted
1866/// histogram with events that have constant weights equal to 1.
1867/// The variance \f$ z_{i}^{2} \f$ of the difference between the weight wi
1868/// and the estimated expectation value of the weight is approximately equal to:
1869///\f[
1870/// 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}
1871///\f]
1872/// The residuals
1873///\f[
1874/// r_{i} = \frac{w_{i}-W\hat{p}_{i}}{z_{i}}
1875///\f]
1876/// have approximately a normal distribution with mean equal to 0 and standard
1877/// deviation equal to 1.
1878///
1879/// #### Two weighted histograms comparison:
1880///
1881/// Let us denote the common weight of events of the ith bin in the first
1882/// histogram as w1i and as w2i in the second one. The total weight of events
1883/// in the first histogram is equal to
1884///\f[
1885/// W_{1} = \sum_{i=1}^{r} w_{1i}
1886///\f]
1887/// and
1888///\f[
1889/// W_{2} = \sum_{i=1}^{r} w_{2i}
1890///\f]
1891/// in the second histogram. Let us formulate the hypothesis of identity of
1892/// weighted histograms so that there exist r constants p1,...,pr, such that
1893///\f[
1894/// \sum_{i=1}^{r} p_{i} = 1
1895///\f]
1896/// and also expectation value of weight w1i equal to W1pi and expectation value
1897/// of weight w2i equal to W2pi. Weights in both the histograms are random
1898/// variables with distributions which can be approximated by a normal
1899/// probability distribution \f$ N(W_{1}p_{i},\sigma_{1i}^{2}) \f$ for the first histogram
1900/// and by a distribution \f$ N(W_{2}p_{i},\sigma_{2i}^{2}) \f$ for the second.
1901/// Here \f$ \sigma_{1i}^{2} \f$ and \f$ \sigma_{2i}^{2} \f$ are the variances
1902/// of w1i and w2i with estimators \f$ s_{1i}^{2} \f$ and \f$ s_{2i}^{2} \f$ respectively.
1903/// If the hypothesis of identity is valid, then the maximum likelihood and
1904/// Least Square Method estimator of pi,i=1,...,r, is
1905///\f[
1906/// \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}}
1907///\f]
1908/// We may then use the test statistic
1909///\f[
1910/// 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}}
1911///\f]
1912/// and it has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [2].
1913/// The normalized or studentised residuals [6]
1914///\f[
1915/// 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})}}}
1916///\f]
1917/// have approximately a normal distribution with mean equal to 0 and standard
1918/// deviation 1. A recommended minimal expected frequency is equal to 10 for
1919/// the proposed test.
1920///
1921/// #### Numerical examples:
1922///
1923/// The method described herein is now illustrated with an example.
1924/// We take a distribution
1925///\f[
1926/// \phi(x) = \frac{2}{(x-10)^{2}+1} + \frac{1}{(x-14)^{2}+1} (1)
1927///\f]
1928/// defined on the interval [4,16]. Events distributed according to the formula
1929/// (1) are simulated to create the unweighted histogram. Uniformly distributed
1930/// events are simulated for the weighted histogram with weights calculated by
1931/// formula (1). Each histogram has the same number of bins: 20. Fig.1 shows
1932/// the result of comparison of the unweighted histogram with 200 events
1933/// (minimal expected frequency equal to one) and the weighted histogram with
1934/// 500 events (minimal expected frequency equal to 25)
1935/// Begin_Macro
1936/// ../../../tutorials/math/chi2test.C
1937/// End_Macro
1938/// Fig 1. An example of comparison of the unweighted histogram with 200 events
1939/// and the weighted histogram with 500 events:
1940/// 1. unweighted histogram;
1941/// 2. weighted histogram;
1942/// 3. normalized residuals plot;
1943/// 4. normal Q-Q plot of residuals.
1944///
1945/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1946/// 21.09 with p-value equal to 0.33, therefore the hypothesis of identity of
1947/// the two histograms can be accepted for 0.05 significant level. The behavior
1948/// of the normalized residuals plot (see Fig. 1c) and the normal Q-Q plot
1949/// (see Fig. 1d) of residuals are regular and we cannot identify the outliers
1950/// or bins with a big influence on \f$ \chi^{2} \f$.
1951///
1952/// The second example presents the same two histograms but 17 events was added
1953/// to content of bin number 15 in unweighted histogram. Fig.2 shows the result
1954/// of comparison of the unweighted histogram with 217 events (minimal expected
1955/// frequency equal to one) and the weighted histogram with 500 events (minimal
1956/// expected frequency equal to 25)
1957/// Begin_Macro
1958/// ../../../tutorials/math/chi2test.C(17)
1959/// End_Macro
1960/// Fig 2. An example of comparison of the unweighted histogram with 217 events
1961/// and the weighted histogram with 500 events:
1962/// 1. unweighted histogram;
1963/// 2. weighted histogram;
1964/// 3. normalized residuals plot;
1965/// 4. normal Q-Q plot of residuals.
1966///
1967/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1968/// 32.33 with p-value equal to 0.029, therefore the hypothesis of identity of
1969/// the two histograms is rejected for 0.05 significant level. The behavior of
1970/// the normalized residuals plot (see Fig. 2c) and the normal Q-Q plot (see
1971/// Fig. 2d) of residuals are not regular and we can identify the outlier or
1972/// bin with a big influence on \f$ \chi^{2} \f$.
1973///
1974/// #### References:
1975///
1976/// - [1] Pearson, K., 1904. On the Theory of Contingency and Its Relation to
1977/// Association and Normal Correlation. Drapers' Co. Memoirs, Biometric
1978/// Series No. 1, London.
1979/// - [2] Gagunashvili, N., 2006. \f$ \sigma^{2} \f$ test for comparison
1980/// of weighted and unweighted histograms. Statistical Problems in Particle
1981/// Physics, Astrophysics and Cosmology, Proceedings of PHYSTAT05,
1982/// Oxford, UK, 12-15 September 2005, Imperial College Press, London, 43-44.
1983/// Gagunashvili,N., Comparison of weighted and unweighted histograms,
1984/// arXiv:physics/0605123, 2006.
1985/// - [3] Cramer, H., 1946. Mathematical methods of statistics.
1986/// Princeton University Press, Princeton.
1987/// - [4] Haberman, S.J., 1973. The analysis of residuals in cross-classified tables.
1988/// Biometrics 29, 205-220.
1989/// - [5] Lewontin, R.C. and Felsenstein, J., 1965. The robustness of homogeneity
1990/// test in 2xN tables. Biometrics 21, 19-33.
1991/// - [6] Seber, G.A.F., Lee, A.J., 2003, Linear Regression Analysis.
1992/// John Wiley & Sons Inc., New York.
1993
1994Double_t TH1::Chi2Test(const TH1* h2, Option_t *option, Double_t *res) const
1995{
1996 Double_t chi2 = 0;
1997 Int_t ndf = 0, igood = 0;
1998
1999 TString opt = option;
2000 opt.ToUpper();
2001
2002 Double_t prob = Chi2TestX(h2,chi2,ndf,igood,option,res);
2003
2004 if(opt.Contains("P")) {
2005 printf("Chi2 = %f, Prob = %g, NDF = %d, igood = %d\n", chi2,prob,ndf,igood);
2006 }
2007 if(opt.Contains("CHI2/NDF")) {
2008 if (ndf == 0) return 0;
2009 return chi2/ndf;
2010 }
2011 if(opt.Contains("CHI2")) {
2012 return chi2;
2013 }
2014
2015 return prob;
2016}
2017
2018////////////////////////////////////////////////////////////////////////////////
2019/// The computation routine of the Chisquare test. For the method description,
2020/// see Chi2Test() function.
2021///
2022/// \return p-value
2023/// \param[in] h2 the second histogram
2024/// \param[in] option
2025/// - "UU" = experiment experiment comparison (unweighted-unweighted)
2026/// - "UW" = experiment MC comparison (unweighted-weighted). Note that the first
2027/// histogram should be unweighted
2028/// - "WW" = MC MC comparison (weighted-weighted)
2029/// - "NORM" = if one or both histograms is scaled
2030/// - "OF" = overflows included
2031/// - "UF" = underflows included
2032/// by default underflows and overflows are not included
2033/// \param[out] igood test output
2034/// - igood=0 - no problems
2035/// - For unweighted unweighted comparison
2036/// - igood=1'There is a bin in the 1st histogram with less than 1 event'
2037/// - igood=2'There is a bin in the 2nd histogram with less than 1 event'
2038/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2039/// - For unweighted weighted comparison
2040/// - igood=1'There is a bin in the 1st histogram with less then 1 event'
2041/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective number of events'
2042/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2043/// - For weighted weighted comparison
2044/// - igood=1'There is a bin in the 1st histogram with less then 10 effective
2045/// number of events'
2046/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective
2047/// number of events'
2048/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2049/// \param[out] chi2 chisquare of the test
2050/// \param[out] ndf number of degrees of freedom (important, when both histograms have the same empty bins)
2051/// \param[out] res normalized residuals for further analysis
2052
2053Double_t TH1::Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option, Double_t *res) const
2054{
2055
2056 Int_t i_start, i_end;
2057 Int_t j_start, j_end;
2058 Int_t k_start, k_end;
2059
2060 Double_t sum1 = 0.0, sumw1 = 0.0;
2061 Double_t sum2 = 0.0, sumw2 = 0.0;
2062
2063 chi2 = 0.0;
2064 ndf = 0;
2065
2066 TString opt = option;
2067 opt.ToUpper();
2068
2069 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
2070
2071 const TAxis *xaxis1 = GetXaxis();
2072 const TAxis *xaxis2 = h2->GetXaxis();
2073 const TAxis *yaxis1 = GetYaxis();
2074 const TAxis *yaxis2 = h2->GetYaxis();
2075 const TAxis *zaxis1 = GetZaxis();
2076 const TAxis *zaxis2 = h2->GetZaxis();
2077
2078 Int_t nbinx1 = xaxis1->GetNbins();
2079 Int_t nbinx2 = xaxis2->GetNbins();
2080 Int_t nbiny1 = yaxis1->GetNbins();
2081 Int_t nbiny2 = yaxis2->GetNbins();
2082 Int_t nbinz1 = zaxis1->GetNbins();
2083 Int_t nbinz2 = zaxis2->GetNbins();
2084
2085 //check dimensions
2086 if (this->GetDimension() != h2->GetDimension() ){
2087 Error("Chi2TestX","Histograms have different dimensions.");
2088 return 0.0;
2089 }
2090
2091 //check number of channels
2092 if (nbinx1 != nbinx2) {
2093 Error("Chi2TestX","different number of x channels");
2094 }
2095 if (nbiny1 != nbiny2) {
2096 Error("Chi2TestX","different number of y channels");
2097 }
2098 if (nbinz1 != nbinz2) {
2099 Error("Chi2TestX","different number of z channels");
2100 }
2101
2102 //check for ranges
2103 i_start = j_start = k_start = 1;
2104 i_end = nbinx1;
2105 j_end = nbiny1;
2106 k_end = nbinz1;
2107
2108 if (xaxis1->TestBit(TAxis::kAxisRange)) {
2109 i_start = xaxis1->GetFirst();
2110 i_end = xaxis1->GetLast();
2111 }
2112 if (yaxis1->TestBit(TAxis::kAxisRange)) {
2113 j_start = yaxis1->GetFirst();
2114 j_end = yaxis1->GetLast();
2115 }
2116 if (zaxis1->TestBit(TAxis::kAxisRange)) {
2117 k_start = zaxis1->GetFirst();
2118 k_end = zaxis1->GetLast();
2119 }
2120
2121
2122 if (opt.Contains("OF")) {
2123 if (GetDimension() == 3) k_end = ++nbinz1;
2124 if (GetDimension() >= 2) j_end = ++nbiny1;
2125 if (GetDimension() >= 1) i_end = ++nbinx1;
2126 }
2127
2128 if (opt.Contains("UF")) {
2129 if (GetDimension() == 3) k_start = 0;
2130 if (GetDimension() >= 2) j_start = 0;
2131 if (GetDimension() >= 1) i_start = 0;
2132 }
2133
2134 ndf = (i_end - i_start + 1) * (j_end - j_start + 1) * (k_end - k_start + 1) - 1;
2135
2136 Bool_t comparisonUU = opt.Contains("UU");
2137 Bool_t comparisonUW = opt.Contains("UW");
2138 Bool_t comparisonWW = opt.Contains("WW");
2139 Bool_t scaledHistogram = opt.Contains("NORM");
2140
2141 if (scaledHistogram && !comparisonUU) {
2142 Info("Chi2TestX", "NORM option should be used together with UU option. It is ignored");
2143 }
2144
2145 // look at histo global bin content and effective entries
2146 Stat_t s[kNstat];
2147 GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2148 Double_t sumBinContent1 = s[0];
2149 Double_t effEntries1 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2150
2151 h2->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2152 Double_t sumBinContent2 = s[0];
2153 Double_t effEntries2 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2154
2155 if (!comparisonUU && !comparisonUW && !comparisonWW ) {
2156 // deduce automatically from type of histogram
2157 if (TMath::Abs(sumBinContent1 - effEntries1) < 1) {
2158 if ( TMath::Abs(sumBinContent2 - effEntries2) < 1) comparisonUU = true;
2159 else comparisonUW = true;
2160 }
2161 else comparisonWW = true;
2162 }
2163 // check unweighted histogram
2164 if (comparisonUW) {
2165 if (TMath::Abs(sumBinContent1 - effEntries1) >= 1) {
2166 Warning("Chi2TestX","First histogram is not unweighted and option UW has been requested");
2167 }
2168 }
2169 if ( (!scaledHistogram && comparisonUU) ) {
2170 if ( ( TMath::Abs(sumBinContent1 - effEntries1) >= 1) || (TMath::Abs(sumBinContent2 - effEntries2) >= 1) ) {
2171 Warning("Chi2TestX","Both histograms are not unweighted and option UU has been requested");
2172 }
2173 }
2174
2175
2176 //get number of events in histogram
2177 if (comparisonUU && scaledHistogram) {
2178 for (Int_t i = i_start; i <= i_end; ++i) {
2179 for (Int_t j = j_start; j <= j_end; ++j) {
2180 for (Int_t k = k_start; k <= k_end; ++k) {
2181
2182 Int_t bin = GetBin(i, j, k);
2183
2184 Double_t cnt1 = RetrieveBinContent(bin);
2185 Double_t cnt2 = h2->RetrieveBinContent(bin);
2186 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2187 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2188
2189 if (e1sq > 0.0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2190 else cnt1 = 0.0;
2191
2192 if (e2sq > 0.0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2193 else cnt2 = 0.0;
2194
2195 // sum contents
2196 sum1 += cnt1;
2197 sum2 += cnt2;
2198 sumw1 += e1sq;
2199 sumw2 += e2sq;
2200 }
2201 }
2202 }
2203 if (sumw1 <= 0.0 || sumw2 <= 0.0) {
2204 Error("Chi2TestX", "Cannot use option NORM when one histogram has all zero errors");
2205 return 0.0;
2206 }
2207
2208 } else {
2209 for (Int_t i = i_start; i <= i_end; ++i) {
2210 for (Int_t j = j_start; j <= j_end; ++j) {
2211 for (Int_t k = k_start; k <= k_end; ++k) {
2212
2213 Int_t bin = GetBin(i, j, k);
2214
2215 sum1 += RetrieveBinContent(bin);
2216 sum2 += h2->RetrieveBinContent(bin);
2217
2218 if ( comparisonWW ) sumw1 += GetBinErrorSqUnchecked(bin);
2219 if ( comparisonUW || comparisonWW ) sumw2 += h2->GetBinErrorSqUnchecked(bin);
2220 }
2221 }
2222 }
2223 }
2224 //checks that the histograms are not empty
2225 if (sum1 == 0.0 || sum2 == 0.0) {
2226 Error("Chi2TestX","one histogram is empty");
2227 return 0.0;
2228 }
2229
2230 if ( comparisonWW && ( sumw1 <= 0.0 && sumw2 <= 0.0 ) ){
2231 Error("Chi2TestX","Hist1 and Hist2 have both all zero errors\n");
2232 return 0.0;
2233 }
2234
2235 //THE TEST
2236 Int_t m = 0, n = 0;
2237
2238 //Experiment - experiment comparison
2239 if (comparisonUU) {
2240 Double_t sum = sum1 + sum2;
2241 for (Int_t i = i_start; i <= i_end; ++i) {
2242 for (Int_t j = j_start; j <= j_end; ++j) {
2243 for (Int_t k = k_start; k <= k_end; ++k) {
2244
2245 Int_t bin = GetBin(i, j, k);
2246
2247 Double_t cnt1 = RetrieveBinContent(bin);
2248 Double_t cnt2 = h2->RetrieveBinContent(bin);
2249
2250 if (scaledHistogram) {
2251 // scale bin value to effective bin entries
2252 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2253 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2254
2255 if (e1sq > 0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2256 else cnt1 = 0;
2257
2258 if (e2sq > 0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2259 else cnt2 = 0;
2260 }
2261
2262 if (Int_t(cnt1) == 0 && Int_t(cnt2) == 0) --ndf; // no data means one degree of freedom less
2263 else {
2264
2265 Double_t cntsum = cnt1 + cnt2;
2266 Double_t nexp1 = cntsum * sum1 / sum;
2267 //Double_t nexp2 = binsum*sum2/sum;
2268
2269 if (res) res[i - i_start] = (cnt1 - nexp1) / TMath::Sqrt(nexp1);
2270
2271 if (cnt1 < 1) ++m;
2272 if (cnt2 < 1) ++n;
2273
2274 //Habermann correction for residuals
2275 Double_t correc = (1. - sum1 / sum) * (1. - cntsum / sum);
2276 if (res) res[i - i_start] /= TMath::Sqrt(correc);
2277
2278 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2279 chi2 += delta * delta / cntsum;
2280 }
2281 }
2282 }
2283 }
2284 chi2 /= sum1 * sum2;
2285
2286 // flag error only when of the two histogram is zero
2287 if (m) {
2288 igood += 1;
2289 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2290 }
2291 if (n) {
2292 igood += 2;
2293 Info("Chi2TestX","There is a bin in h2 with less than 1 event.\n");
2294 }
2295
2296 Double_t prob = TMath::Prob(chi2,ndf);
2297 return prob;
2298
2299 }
2300
2301 // unweighted - weighted comparison
2302 // case of error = 0 and content not zero is treated without problems by excluding second chi2 sum
2303 // and can be considered as a data-theory comparison
2304 if ( comparisonUW ) {
2305 for (Int_t i = i_start; i <= i_end; ++i) {
2306 for (Int_t j = j_start; j <= j_end; ++j) {
2307 for (Int_t k = k_start; k <= k_end; ++k) {
2308
2309 Int_t bin = GetBin(i, j, k);
2310
2311 Double_t cnt1 = RetrieveBinContent(bin);
2312 Double_t cnt2 = h2->RetrieveBinContent(bin);
2313 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2314
2315 // case both histogram have zero bin contents
2316 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2317 --ndf; //no data means one degree of freedom less
2318 continue;
2319 }
2320
2321 // case weighted histogram has zero bin content and error
2322 if (cnt2 * cnt2 == 0 && e2sq == 0) {
2323 if (sumw2 > 0) {
2324 // use as approximated error as 1 scaled by a scaling ratio
2325 // estimated from the total sum weight and sum weight squared
2326 e2sq = sumw2 / sum2;
2327 }
2328 else {
2329 // return error because infinite discrepancy here:
2330 // bin1 != 0 and bin2 =0 in a histogram with all errors zero
2331 Error("Chi2TestX","Hist2 has in bin (%d,%d,%d) zero content and zero errors\n", i, j, k);
2332 chi2 = 0; return 0;
2333 }
2334 }
2335
2336 if (cnt1 < 1) m++;
2337 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2338
2339 Double_t var1 = sum2 * cnt2 - sum1 * e2sq;
2340 Double_t var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2341
2342 // if cnt1 is zero and cnt2 = 1 and sum1 = sum2 var1 = 0 && var2 == 0
2343 // approximate by incrementing cnt1
2344 // LM (this need to be fixed for numerical errors)
2345 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2346 sum1++;
2347 cnt1++;
2348 var1 = sum2 * cnt2 - sum1 * e2sq;
2349 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2350 }
2351 var2 = TMath::Sqrt(var2);
2352
2353 while (var1 + var2 == 0) {
2354 sum1++;
2355 cnt1++;
2356 var1 = sum2 * cnt2 - sum1 * e2sq;
2357 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2358 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2359 sum1++;
2360 cnt1++;
2361 var1 = sum2 * cnt2 - sum1 * e2sq;
2362 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2363 }
2364 var2 = TMath::Sqrt(var2);
2365 }
2366
2367 Double_t probb = (var1 + var2) / (2. * sum2 * sum2);
2368
2369 Double_t nexp1 = probb * sum1;
2370 Double_t nexp2 = probb * sum2;
2371
2372 Double_t delta1 = cnt1 - nexp1;
2373 Double_t delta2 = cnt2 - nexp2;
2374
2375 chi2 += delta1 * delta1 / nexp1;
2376
2377 if (e2sq > 0) {
2378 chi2 += delta2 * delta2 / e2sq;
2379 }
2380
2381 if (res) {
2382 if (e2sq > 0) {
2383 Double_t temp1 = sum2 * e2sq / var2;
2384 Double_t temp2 = 1.0 + (sum1 * e2sq - sum2 * cnt2) / var2;
2385 temp2 = temp1 * temp1 * sum1 * probb * (1.0 - probb) + temp2 * temp2 * e2sq / 4.0;
2386 // invert sign here
2387 res[i - i_start] = - delta2 / TMath::Sqrt(temp2);
2388 }
2389 else
2390 res[i - i_start] = delta1 / TMath::Sqrt(nexp1);
2391 }
2392 }
2393 }
2394 }
2395
2396 if (m) {
2397 igood += 1;
2398 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2399 }
2400 if (n) {
2401 igood += 2;
2402 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2403 }
2404
2405 Double_t prob = TMath::Prob(chi2, ndf);
2406
2407 return prob;
2408 }
2409
2410 // weighted - weighted comparison
2411 if (comparisonWW) {
2412 for (Int_t i = i_start; i <= i_end; ++i) {
2413 for (Int_t j = j_start; j <= j_end; ++j) {
2414 for (Int_t k = k_start; k <= k_end; ++k) {
2415
2416 Int_t bin = GetBin(i, j, k);
2417 Double_t cnt1 = RetrieveBinContent(bin);
2418 Double_t cnt2 = h2->RetrieveBinContent(bin);
2419 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2420 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2421
2422 // case both histogram have zero bin contents
2423 // (use square of content to avoid numerical errors)
2424 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2425 --ndf; //no data means one degree of freedom less
2426 continue;
2427 }
2428
2429 if (e1sq == 0 && e2sq == 0) {
2430 // cannot treat case of booth histogram have zero zero errors
2431 Error("Chi2TestX","h1 and h2 both have bin %d,%d,%d with all zero errors\n", i,j,k);
2432 chi2 = 0; return 0;
2433 }
2434
2435 Double_t sigma = sum1 * sum1 * e2sq + sum2 * sum2 * e1sq;
2436 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2437 chi2 += delta * delta / sigma;
2438
2439 if (res) {
2440 Double_t temp = cnt1 * sum1 * e2sq + cnt2 * sum2 * e1sq;
2441 Double_t probb = temp / sigma;
2442 Double_t z = 0;
2443 if (e1sq > e2sq) {
2444 Double_t d1 = cnt1 - sum1 * probb;
2445 Double_t s1 = e1sq * ( 1. - e2sq * sum1 * sum1 / sigma );
2446 z = d1 / TMath::Sqrt(s1);
2447 }
2448 else {
2449 Double_t d2 = cnt2 - sum2 * probb;
2450 Double_t s2 = e2sq * ( 1. - e1sq * sum2 * sum2 / sigma );
2451 z = -d2 / TMath::Sqrt(s2);
2452 }
2453 res[i - i_start] = z;
2454 }
2455
2456 if (e1sq > 0 && cnt1 * cnt1 / e1sq < 10) m++;
2457 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2458 }
2459 }
2460 }
2461 if (m) {
2462 igood += 1;
2463 Info("Chi2TestX","There is a bin in h1 with less than 10 effective events.\n");
2464 }
2465 if (n) {
2466 igood += 2;
2467 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2468 }
2469 Double_t prob = TMath::Prob(chi2, ndf);
2470 return prob;
2471 }
2472 return 0;
2473}
2474////////////////////////////////////////////////////////////////////////////////
2475/// Compute and return the chisquare of this histogram with respect to a function
2476/// The chisquare is computed by weighting each histogram point by the bin error
2477/// By default the full range of the histogram is used.
2478/// Use option "R" for restricting the chisquare calculation to the given range of the function
2479/// Use option "L" for using the chisquare based on the poisson likelihood (Baker-Cousins Chisquare)
2480
2482{
2483 if (!func) {
2484 Error("Chisquare","Function pointer is Null - return -1");
2485 return -1;
2486 }
2487
2488 TString opt(option); opt.ToUpper();
2489 bool useRange = opt.Contains("R");
2490 bool usePL = opt.Contains("L");
2491
2492 return ROOT::Fit::Chisquare(*this, *func, useRange, usePL);
2493}
2494
2495////////////////////////////////////////////////////////////////////////////////
2496/// Remove all the content from the underflow and overflow bins, without changing the number of entries
2497/// After calling this method, every undeflow and overflow bins will have content 0.0
2498/// The Sumw2 is also cleared, since there is no more content in the bins
2499
2501{
2502 for (Int_t bin = 0; bin < fNcells; ++bin)
2503 if (IsBinUnderflow(bin) || IsBinOverflow(bin)) {
2504 UpdateBinContent(bin, 0.0);
2505 if (fSumw2.fN) fSumw2.fArray[bin] = 0.0;
2506 }
2507}
2508
2509////////////////////////////////////////////////////////////////////////////////
2510/// Compute integral (cumulative sum of bins)
2511/// The result stored in fIntegral is used by the GetRandom functions.
2512/// This function is automatically called by GetRandom when the fIntegral
2513/// array does not exist or when the number of entries in the histogram
2514/// has changed since the previous call to GetRandom.
2515/// The resulting integral is normalized to 1
2516/// If the routine is called with the onlyPositive flag set an error will
2517/// be produced in case of negative bin content and a NaN value returned
2518
2520{
2521 if (fBuffer) BufferEmpty();
2522
2523 // delete previously computed integral (if any)
2524 if (fIntegral) delete [] fIntegral;
2525
2526 // - Allocate space to store the integral and compute integral
2527 Int_t nbinsx = GetNbinsX();
2528 Int_t nbinsy = GetNbinsY();
2529 Int_t nbinsz = GetNbinsZ();
2530 Int_t nbins = nbinsx * nbinsy * nbinsz;
2531
2532 fIntegral = new Double_t[nbins + 2];
2533 Int_t ibin = 0; fIntegral[ibin] = 0;
2534
2535 for (Int_t binz=1; binz <= nbinsz; ++binz) {
2536 for (Int_t biny=1; biny <= nbinsy; ++biny) {
2537 for (Int_t binx=1; binx <= nbinsx; ++binx) {
2538 ++ibin;
2539 Double_t y = RetrieveBinContent(GetBin(binx, biny, binz));
2540 if (onlyPositive && y < 0) {
2541 Error("ComputeIntegral","Bin content is negative - return a NaN value");
2542 fIntegral[nbins] = TMath::QuietNaN();
2543 break;
2544 }
2545 fIntegral[ibin] = fIntegral[ibin - 1] + y;
2546 }
2547 }
2548 }
2549
2550 // - Normalize integral to 1
2551 if (fIntegral[nbins] == 0 ) {
2552 Error("ComputeIntegral", "Integral = zero"); return 0;
2553 }
2554 for (Int_t bin=1; bin <= nbins; ++bin) fIntegral[bin] /= fIntegral[nbins];
2555 fIntegral[nbins+1] = fEntries;
2556 return fIntegral[nbins];
2557}
2558
2559////////////////////////////////////////////////////////////////////////////////
2560/// Return a pointer to the array of bins integral.
2561/// if the pointer fIntegral is null, TH1::ComputeIntegral is called
2562/// The array dimension is the number of bins in the histograms
2563/// including underflow and overflow (fNCells)
2564/// the last value integral[fNCells] is set to the number of entries of
2565/// the histogram
2566
2568{
2569 if (!fIntegral) ComputeIntegral();
2570 return fIntegral;
2571}
2572
2573////////////////////////////////////////////////////////////////////////////////
2574/// Return a pointer to a histogram containing the cumulative content.
2575/// The cumulative can be computed both in the forward (default) or backward
2576/// direction; the name of the new histogram is constructed from
2577/// the name of this histogram with the suffix "suffix" appended provided
2578/// by the user. If not provided a default suffix="_cumulative" is used.
2579///
2580/// The cumulative distribution is formed by filling each bin of the
2581/// resulting histogram with the sum of that bin and all previous
2582/// (forward == kTRUE) or following (forward = kFALSE) bins.
2583///
2584/// Note: while cumulative distributions make sense in one dimension, you
2585/// may not be getting what you expect in more than 1D because the concept
2586/// of a cumulative distribution is much trickier to define; make sure you
2587/// understand the order of summation before you use this method with
2588/// histograms of dimension >= 2.
2589///
2590/// Note 2: By default the cumulative is computed from bin 1 to Nbins
2591/// If an axis range is set, values between the minimum and maximum of the range
2592/// are set.
2593/// Setting an axis range can also be used for including underflow and overflow in
2594/// the cumulative (e.g. by setting h->GetXaxis()->SetRange(0, h->GetNbinsX()+1); )
2596
2597TH1 *TH1::GetCumulative(Bool_t forward, const char* suffix) const
2598{
2599 const Int_t firstX = fXaxis.GetFirst();
2600 const Int_t lastX = fXaxis.GetLast();
2601 const Int_t firstY = (fDimension > 1) ? fYaxis.GetFirst() : 1;
2602 const Int_t lastY = (fDimension > 1) ? fYaxis.GetLast() : 1;
2603 const Int_t firstZ = (fDimension > 1) ? fZaxis.GetFirst() : 1;
2604 const Int_t lastZ = (fDimension > 1) ? fZaxis.GetLast() : 1;
2605
2606 TH1* hintegrated = (TH1*) Clone(fName + suffix);
2607 hintegrated->Reset();
2608 Double_t sum = 0.;
2609 Double_t esum = 0;
2610 if (forward) { // Forward computation
2611 for (Int_t binz = firstZ; binz <= lastZ; ++binz) {
2612 for (Int_t biny = firstY; biny <= lastY; ++biny) {
2613 for (Int_t binx = firstX; binx <= lastX; ++binx) {
2614 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2615 sum += RetrieveBinContent(bin);
2616 hintegrated->AddBinContent(bin, sum);
2617 if (fSumw2.fN) {
2618 esum += GetBinErrorSqUnchecked(bin);
2619 fSumw2.fArray[bin] = esum;
2620 }
2621 }
2622 }
2623 }
2624 } else { // Backward computation
2625 for (Int_t binz = lastZ; binz >= firstZ; --binz) {
2626 for (Int_t biny = lastY; biny >= firstY; --biny) {
2627 for (Int_t binx = lastX; binx >= firstX; --binx) {
2628 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2629 sum += RetrieveBinContent(bin);
2630 hintegrated->AddBinContent(bin, sum);
2631 if (fSumw2.fN) {
2632 esum += GetBinErrorSqUnchecked(bin);
2633 fSumw2.fArray[bin] = esum;
2634 }
2635 }
2636 }
2637 }
2638 }
2639 return hintegrated;
2640}
2641
2642////////////////////////////////////////////////////////////////////////////////
2643/// Copy this histogram structure to newth1.
2644///
2645/// Note that this function does not copy the list of associated functions.
2646/// Use TObject::Clone to make a full copy of a histogram.
2647///
2648/// Note also that the histogram it will be created in gDirectory (if AddDirectoryStatus()=true)
2649/// or will not be added to any directory if AddDirectoryStatus()=false
2650/// independently of the current directory stored in the original histogram
2651
2652void TH1::Copy(TObject &obj) const
2653{
2654 if (((TH1&)obj).fDirectory) {
2655 // We are likely to change the hash value of this object
2656 // with TNamed::Copy, to keep things correct, we need to
2657 // clean up its existing entries.
2658 ((TH1&)obj).fDirectory->Remove(&obj);
2659 ((TH1&)obj).fDirectory = nullptr;
2660 }
2661 TNamed::Copy(obj);
2662 ((TH1&)obj).fDimension = fDimension;
2663 ((TH1&)obj).fNormFactor= fNormFactor;
2664 ((TH1&)obj).fNcells = fNcells;
2665 ((TH1&)obj).fBarOffset = fBarOffset;
2666 ((TH1&)obj).fBarWidth = fBarWidth;
2667 ((TH1&)obj).fOption = fOption;
2668 ((TH1&)obj).fBinStatErrOpt = fBinStatErrOpt;
2669 ((TH1&)obj).fBufferSize= fBufferSize;
2670 // copy the Buffer
2671 // delete first a previously existing buffer
2672 if (((TH1&)obj).fBuffer != nullptr) {
2673 delete [] ((TH1&)obj).fBuffer;
2674 ((TH1&)obj).fBuffer = nullptr;
2675 }
2676 if (fBuffer) {
2677 Double_t *buf = new Double_t[fBufferSize];
2678 for (Int_t i=0;i<fBufferSize;i++) buf[i] = fBuffer[i];
2679 // obj.fBuffer has been deleted before
2680 ((TH1&)obj).fBuffer = buf;
2681 }
2682
2683
2684 TArray* a = dynamic_cast<TArray*>(&obj);
2685 if (a) a->Set(fNcells);
2686 for (Int_t i = 0; i < fNcells; i++) ((TH1&)obj).UpdateBinContent(i, RetrieveBinContent(i));
2687
2688 ((TH1&)obj).fEntries = fEntries;
2689
2690 // which will call BufferEmpty(0) and set fBuffer[0] to a Maybe one should call
2691 // assignment operator on the TArrayD
2692
2693 ((TH1&)obj).fTsumw = fTsumw;
2694 ((TH1&)obj).fTsumw2 = fTsumw2;
2695 ((TH1&)obj).fTsumwx = fTsumwx;
2696 ((TH1&)obj).fTsumwx2 = fTsumwx2;
2697 ((TH1&)obj).fMaximum = fMaximum;
2698 ((TH1&)obj).fMinimum = fMinimum;
2699
2700 TAttLine::Copy(((TH1&)obj));
2701 TAttFill::Copy(((TH1&)obj));
2702 TAttMarker::Copy(((TH1&)obj));
2703 fXaxis.Copy(((TH1&)obj).fXaxis);
2704 fYaxis.Copy(((TH1&)obj).fYaxis);
2705 fZaxis.Copy(((TH1&)obj).fZaxis);
2706 ((TH1&)obj).fXaxis.SetParent(&obj);
2707 ((TH1&)obj).fYaxis.SetParent(&obj);
2708 ((TH1&)obj).fZaxis.SetParent(&obj);
2709 fContour.Copy(((TH1&)obj).fContour);
2710 fSumw2.Copy(((TH1&)obj).fSumw2);
2711 // fFunctions->Copy(((TH1&)obj).fFunctions);
2712 // when copying an histogram if the AddDirectoryStatus() is true it
2713 // will be added to gDirectory independently of the fDirectory stored.
2714 // and if the AddDirectoryStatus() is false it will not be added to
2715 // any directory (fDirectory = nullptr)
2716 if (fgAddDirectory && gDirectory) {
2717 gDirectory->Append(&obj);
2718 ((TH1&)obj).fFunctions->UseRWLock();
2719 ((TH1&)obj).fDirectory = gDirectory;
2720 } else
2721 ((TH1&)obj).fDirectory = nullptr;
2722
2723}
2724
2725////////////////////////////////////////////////////////////////////////////////
2726/// Make a complete copy of the underlying object. If 'newname' is set,
2727/// the copy's name will be set to that name.
2728
2729TObject* TH1::Clone(const char* newname) const
2730{
2731 TH1* obj = (TH1*)IsA()->GetNew()(0);
2732 Copy(*obj);
2733
2734 // Now handle the parts that Copy doesn't do
2735 if(fFunctions) {
2736 // The Copy above might have published 'obj' to the ListOfCleanups.
2737 // Clone can call RecursiveRemove, for example via TCheckHashRecursiveRemoveConsistency
2738 // when dictionary information is initialized, so we need to
2739 // keep obj->fFunction valid during its execution and
2740 // protect the update with the write lock.
2741
2742 // Reset stats parent - else cloning the stats will clone this histogram, too.
2743 auto oldstats = dynamic_cast<TVirtualPaveStats*>(fFunctions->FindObject("stats"));
2744 TObject *oldparent = nullptr;
2745 if (oldstats) {
2746 oldparent = oldstats->GetParent();
2747 oldstats->SetParent(nullptr);
2748 }
2749
2750 auto newlist = (TList*)fFunctions->Clone();
2751
2752 if (oldstats)
2753 oldstats->SetParent(oldparent);
2754 auto newstats = dynamic_cast<TVirtualPaveStats*>(obj->fFunctions->FindObject("stats"));
2755 if (newstats)
2756 newstats->SetParent(obj);
2757
2758 auto oldlist = obj->fFunctions;
2759 {
2761 obj->fFunctions = newlist;
2762 }
2763 delete oldlist;
2764 }
2765 if(newname && strlen(newname) ) {
2766 obj->SetName(newname);
2767 }
2768 return obj;
2769}
2770
2771////////////////////////////////////////////////////////////////////////////////
2772/// Perform the automatic addition of the histogram to the given directory
2773///
2774/// Note this function is called in place when the semantic requires
2775/// this object to be added to a directory (I.e. when being read from
2776/// a TKey or being Cloned)
2777
2779{
2780 Bool_t addStatus = TH1::AddDirectoryStatus();
2781 if (addStatus) {
2782 SetDirectory(dir);
2783 if (dir) {
2785 }
2786 }
2787}
2788
2789////////////////////////////////////////////////////////////////////////////////
2790/// Compute distance from point px,py to a line.
2791///
2792/// Compute the closest distance of approach from point px,py to elements
2793/// of a histogram.
2794/// The distance is computed in pixels units.
2795///
2796/// #### Algorithm:
2797/// Currently, this simple model computes the distance from the mouse
2798/// to the histogram contour only.
2799
2801{
2802 if (!fPainter) return 9999;
2803 return fPainter->DistancetoPrimitive(px,py);
2804}
2805
2806////////////////////////////////////////////////////////////////////////////////
2807/// Performs the operation: `this = this/(c1*f1)`
2808/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2809///
2810/// Only bins inside the function range are recomputed.
2811/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2812/// you should call Sumw2 before making this operation.
2813/// This is particularly important if you fit the histogram after TH1::Divide
2814///
2815/// The function return kFALSE if the divide operation failed
2816
2818{
2819 if (!f1) {
2820 Error("Divide","Attempt to divide by a non-existing function");
2821 return kFALSE;
2822 }
2823
2824 // delete buffer if it is there since it will become invalid
2825 if (fBuffer) BufferEmpty(1);
2826
2827 Int_t nx = GetNbinsX() + 2; // normal bins + uf / of
2828 Int_t ny = GetNbinsY() + 2;
2829 Int_t nz = GetNbinsZ() + 2;
2830 if (fDimension < 2) ny = 1;
2831 if (fDimension < 3) nz = 1;
2832
2833
2834 SetMinimum();
2835 SetMaximum();
2836
2837 // - Loop on bins (including underflows/overflows)
2838 Int_t bin, binx, biny, binz;
2839 Double_t cu, w;
2840 Double_t xx[3];
2841 Double_t *params = 0;
2842 f1->InitArgs(xx,params);
2843 for (binz = 0; binz < nz; ++binz) {
2844 xx[2] = fZaxis.GetBinCenter(binz);
2845 for (biny = 0; biny < ny; ++biny) {
2846 xx[1] = fYaxis.GetBinCenter(biny);
2847 for (binx = 0; binx < nx; ++binx) {
2848 xx[0] = fXaxis.GetBinCenter(binx);
2849 if (!f1->IsInside(xx)) continue;
2851 bin = binx + nx * (biny + ny * binz);
2852 cu = c1 * f1->EvalPar(xx);
2853 if (TF1::RejectedPoint()) continue;
2854 if (cu) w = RetrieveBinContent(bin) / cu;
2855 else w = 0;
2856 UpdateBinContent(bin, w);
2857 if (fSumw2.fN) {
2858 if (cu != 0) fSumw2.fArray[bin] = GetBinErrorSqUnchecked(bin) / (cu * cu);
2859 else fSumw2.fArray[bin] = 0;
2860 }
2861 }
2862 }
2863 }
2864 ResetStats();
2865 return kTRUE;
2866}
2867
2868////////////////////////////////////////////////////////////////////////////////
2869/// Divide this histogram by h1.
2870///
2871/// `this = this/h1`
2872/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2873/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
2874/// if not already set.
2875/// The resulting errors are calculated assuming uncorrelated histograms.
2876/// See the other TH1::Divide that gives the possibility to optionally
2877/// compute binomial errors.
2878///
2879/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2880/// you should call Sumw2 before making this operation.
2881/// This is particularly important if you fit the histogram after TH1::Scale
2882///
2883/// The function return kFALSE if the divide operation failed
2884
2885Bool_t TH1::Divide(const TH1 *h1)
2886{
2887 if (!h1) {
2888 Error("Divide", "Input histogram passed does not exist (NULL).");
2889 return kFALSE;
2890 }
2891
2892 // delete buffer if it is there since it will become invalid
2893 if (fBuffer) BufferEmpty(1);
2894
2895 try {
2896 CheckConsistency(this,h1);
2897 } catch(DifferentNumberOfBins&) {
2898 Error("Divide","Cannot divide histograms with different number of bins");
2899 return kFALSE;
2900 } catch(DifferentAxisLimits&) {
2901 Warning("Divide","Dividing histograms with different axis limits");
2902 } catch(DifferentBinLimits&) {
2903 Warning("Divide","Dividing histograms with different bin limits");
2904 } catch(DifferentLabels&) {
2905 Warning("Divide","Dividing histograms with different labels");
2906 }
2907
2908 // Create Sumw2 if h1 has Sumw2 set
2909 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
2910
2911 // - Loop on bins (including underflows/overflows)
2912 for (Int_t i = 0; i < fNcells; ++i) {
2915 if (c1) UpdateBinContent(i, c0 / c1);
2916 else UpdateBinContent(i, 0);
2917
2918 if(fSumw2.fN) {
2919 if (c1 == 0) { fSumw2.fArray[i] = 0; continue; }
2920 Double_t c1sq = c1 * c1;
2921 fSumw2.fArray[i] = (GetBinErrorSqUnchecked(i) * c1sq + h1->GetBinErrorSqUnchecked(i) * c0 * c0) / (c1sq * c1sq);
2922 }
2923 }
2924 ResetStats();
2925 return kTRUE;
2926}
2927
2928////////////////////////////////////////////////////////////////////////////////
2929/// Replace contents of this histogram by the division of h1 by h2.
2930///
2931/// `this = c1*h1/(c2*h2)`
2932///
2933/// If errors are defined (see TH1::Sumw2), errors are also recalculated
2934/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
2935/// if not already set.
2936/// The resulting errors are calculated assuming uncorrelated histograms.
2937/// However, if option ="B" is specified, Binomial errors are computed.
2938/// In this case c1 and c2 do not make real sense and they are ignored.
2939///
2940/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2941/// you should call Sumw2 before making this operation.
2942/// This is particularly important if you fit the histogram after TH1::Divide
2943///
2944/// Please note also that in the binomial case errors are calculated using standard
2945/// binomial statistics, which means when b1 = b2, the error is zero.
2946/// If you prefer to have efficiency errors not going to zero when the efficiency is 1, you must
2947/// use the function TGraphAsymmErrors::BayesDivide, which will return an asymmetric and non-zero lower
2948/// error for the case b1=b2.
2949///
2950/// The function return kFALSE if the divide operation failed
2951
2953{
2954
2955 TString opt = option;
2956 opt.ToLower();
2957 Bool_t binomial = kFALSE;
2958 if (opt.Contains("b")) binomial = kTRUE;
2959 if (!h1 || !h2) {
2960 Error("Divide", "At least one of the input histograms passed does not exist (NULL).");
2961 return kFALSE;
2962 }
2963
2964 // delete buffer if it is there since it will become invalid
2965 if (fBuffer) BufferEmpty(1);
2966
2967 try {
2968 CheckConsistency(h1,h2);
2969 CheckConsistency(this,h1);
2970 } catch(DifferentNumberOfBins&) {
2971 Error("Divide","Cannot divide histograms with different number of bins");
2972 return kFALSE;
2973 } catch(DifferentAxisLimits&) {
2974 Warning("Divide","Dividing histograms with different axis limits");
2975 } catch(DifferentBinLimits&) {
2976 Warning("Divide","Dividing histograms with different bin limits");
2977 } catch(DifferentLabels&) {
2978 Warning("Divide","Dividing histograms with different labels");
2979 }
2980
2981
2982 if (!c2) {
2983 Error("Divide","Coefficient of dividing histogram cannot be zero");
2984 return kFALSE;
2985 }
2986
2987 // Create Sumw2 if h1 or h2 have Sumw2 set, or if binomial errors are explicitly requested
2988 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0 || binomial)) Sumw2();
2989
2990 SetMinimum();
2991 SetMaximum();
2992
2993 // - Loop on bins (including underflows/overflows)
2994 for (Int_t i = 0; i < fNcells; ++i) {
2996 Double_t b2 = h2->RetrieveBinContent(i);
2997 if (b2) UpdateBinContent(i, c1 * b1 / (c2 * b2));
2998 else UpdateBinContent(i, 0);
2999
3000 if (fSumw2.fN) {
3001 if (b2 == 0) { fSumw2.fArray[i] = 0; continue; }
3002 Double_t b1sq = b1 * b1; Double_t b2sq = b2 * b2;
3003 Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
3005 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
3006 if (binomial) {
3007 if (b1 != b2) {
3008 // in the case of binomial statistics c1 and c2 must be 1 otherwise it does not make sense
3009 // c1 and c2 are ignored
3010 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));//this is the formula in Hbook/Hoper1
3011 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/b2); // old formula from G. Flucke
3012 // formula which works also for weighted histogram (see http://root-forum.cern.ch/viewtopic.php?t=3753 )
3013 fSumw2.fArray[i] = TMath::Abs( ( (1. - 2.* b1 / b2) * e1sq + b1sq * e2sq / b2sq ) / b2sq );
3014 } else {
3015 //in case b1=b2 error is zero
3016 //use TGraphAsymmErrors::BayesDivide for getting the asymmetric error not equal to zero
3017 fSumw2.fArray[i] = 0;
3018 }
3019 } else {
3020 fSumw2.fArray[i] = c1sq * c2sq * (e1sq * b2sq + e2sq * b1sq) / (c2sq * c2sq * b2sq * b2sq);
3021 }
3022 }
3023 }
3024 ResetStats();
3025 if (binomial)
3026 // in case of binomial division use denominator for number of entries
3027 SetEntries ( h2->GetEntries() );
3028
3029 return kTRUE;
3030}
3031
3032////////////////////////////////////////////////////////////////////////////////
3033/// Draw this histogram with options.
3034///
3035/// Histograms are drawn via the THistPainter class. Each histogram has
3036/// a pointer to its own painter (to be usable in a multithreaded program).
3037/// The same histogram can be drawn with different options in different pads.
3038/// When a histogram drawn in a pad is deleted, the histogram is
3039/// automatically removed from the pad or pads where it was drawn.
3040/// If a histogram is drawn in a pad, then filled again, the new status
3041/// of the histogram will be automatically shown in the pad next time
3042/// the pad is updated. One does not need to redraw the histogram.
3043/// To draw the current version of a histogram in a pad, one can use
3044/// `h->DrawCopy();`
3045/// This makes a clone of the histogram. Once the clone is drawn, the original
3046/// histogram may be modified or deleted without affecting the aspect of the
3047/// clone.
3048/// By default, TH1::Draw clears the current pad.
3049///
3050/// One can use TH1::SetMaximum and TH1::SetMinimum to force a particular
3051/// value for the maximum or the minimum scale on the plot.
3052///
3053/// TH1::UseCurrentStyle can be used to change all histogram graphics
3054/// attributes to correspond to the current selected style.
3055/// This function must be called for each histogram.
3056/// In case one reads and draws many histograms from a file, one can force
3057/// the histograms to inherit automatically the current graphics style
3058/// by calling before gROOT->ForceStyle();
3059///
3060/// See the THistPainter class for a description of all the drawing options.
3061
3063{
3064 TString opt1 = option; opt1.ToLower();
3065 TString opt2 = option;
3066 Int_t index = opt1.Index("same");
3067
3068 // Check if the string "same" is part of a TCutg name.
3069 if (index>=0) {
3070 Int_t indb = opt1.Index("[");
3071 if (indb>=0) {
3072 Int_t indk = opt1.Index("]");
3073 if (index>indb && index<indk) index = -1;
3074 }
3075 }
3076
3077 // If there is no pad or an empty pad the "same" option is ignored.
3078 if (gPad) {
3079 if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
3080 if (index>=0) {
3081 if (gPad->GetX1() == 0 && gPad->GetX2() == 1 &&
3082 gPad->GetY1() == 0 && gPad->GetY2() == 1 &&
3083 gPad->GetListOfPrimitives()->GetSize()==0) opt2.Remove(index,4);
3084 } else {
3085 //the following statement is necessary in case one attempts to draw
3086 //a temporary histogram already in the current pad
3087 if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this);
3088 gPad->Clear();
3089 }
3090 gPad->IncrementPaletteColor(1, opt1);
3091 } else {
3092 if (index>=0) opt2.Remove(index,4);
3093 }
3094
3095 AppendPad(opt2.Data());
3096}
3097
3098////////////////////////////////////////////////////////////////////////////////
3099/// Copy this histogram and Draw in the current pad.
3100///
3101/// Once the histogram is drawn into the pad, any further modification
3102/// using graphics input will be made on the copy of the histogram,
3103/// and not to the original object.
3104/// By default a postfix "_copy" is added to the histogram name. Pass an empty postfix in case
3105/// you want to draw a histogram with the same name
3106///
3107/// See Draw for the list of options
3108
3109TH1 *TH1::DrawCopy(Option_t *option, const char * name_postfix) const
3110{
3111 TString opt = option;
3112 opt.ToLower();
3113 if (gPad && !opt.Contains("same")) gPad->Clear();
3114 TString newName;
3115 if (name_postfix) newName.Form("%s%s", GetName(), name_postfix);
3116 TH1 *newth1 = (TH1 *)Clone(newName.Data());
3117 newth1->SetDirectory(nullptr);
3118 newth1->SetBit(kCanDelete);
3119 if (gPad) gPad->IncrementPaletteColor(1, opt);
3120
3121 newth1->AppendPad(option);
3122 return newth1;
3123}
3124
3125////////////////////////////////////////////////////////////////////////////////
3126/// Draw a normalized copy of this histogram.
3127///
3128/// A clone of this histogram is normalized to norm and drawn with option.
3129/// A pointer to the normalized histogram is returned.
3130/// The contents of the histogram copy are scaled such that the new
3131/// sum of weights (excluding under and overflow) is equal to norm.
3132/// Note that the returned normalized histogram is not added to the list
3133/// of histograms in the current directory in memory.
3134/// It is the user's responsibility to delete this histogram.
3135/// The kCanDelete bit is set for the returned object. If a pad containing
3136/// this copy is cleared, the histogram will be automatically deleted.
3137///
3138/// See Draw for the list of options
3139
3141{
3143 if (sum == 0) {
3144 Error("DrawNormalized","Sum of weights is null. Cannot normalize histogram: %s",GetName());
3145 return nullptr;
3146 }
3147 Bool_t addStatus = TH1::AddDirectoryStatus();
3149 TH1 *h = (TH1*)Clone();
3150 h->SetBit(kCanDelete);
3151 // in case of drawing with error options - scale correctly the error
3152 TString opt(option); opt.ToUpper();
3153 if (fSumw2.fN == 0) {
3154 h->Sumw2();
3155 // do not use in this case the "Error option " for drawing which is enabled by default since the normalized histogram has now errors
3156 if (opt.IsNull() || opt == "SAME") opt += "HIST";
3157 }
3158 h->Scale(norm/sum);
3159 if (TMath::Abs(fMaximum+1111) > 1e-3) h->SetMaximum(fMaximum*norm/sum);
3160 if (TMath::Abs(fMinimum+1111) > 1e-3) h->SetMinimum(fMinimum*norm/sum);
3161 h->Draw(opt);
3162 TH1::AddDirectory(addStatus);
3163 return h;
3164}
3165
3166////////////////////////////////////////////////////////////////////////////////
3167/// Display a panel with all histogram drawing options.
3168///
3169/// See class TDrawPanelHist for example
3170
3171void TH1::DrawPanel()
3172{
3173 if (!fPainter) {Draw(); if (gPad) gPad->Update();}
3174 if (fPainter) fPainter->DrawPanel();
3175}
3176
3177////////////////////////////////////////////////////////////////////////////////
3178/// Evaluate function f1 at the center of bins of this histogram.
3179///
3180/// - If option "R" is specified, the function is evaluated only
3181/// for the bins included in the function range.
3182/// - If option "A" is specified, the value of the function is added to the
3183/// existing bin contents
3184/// - If option "S" is specified, the value of the function is used to
3185/// generate a value, distributed according to the Poisson
3186/// distribution, with f1 as the mean.
3187
3189{
3190 Double_t x[3];
3191 Int_t range, stat, add;
3192 if (!f1) return;
3193
3194 TString opt = option;
3195 opt.ToLower();
3196 if (opt.Contains("a")) add = 1;
3197 else add = 0;
3198 if (opt.Contains("s")) stat = 1;
3199 else stat = 0;
3200 if (opt.Contains("r")) range = 1;
3201 else range = 0;
3202
3203 // delete buffer if it is there since it will become invalid
3204 if (fBuffer) BufferEmpty(1);
3205
3206 Int_t nbinsx = fXaxis.GetNbins();
3207 Int_t nbinsy = fYaxis.GetNbins();
3208 Int_t nbinsz = fZaxis.GetNbins();
3209 if (!add) Reset();
3210
3211 for (Int_t binz = 1; binz <= nbinsz; ++binz) {
3212 x[2] = fZaxis.GetBinCenter(binz);
3213 for (Int_t biny = 1; biny <= nbinsy; ++biny) {
3214 x[1] = fYaxis.GetBinCenter(biny);
3215 for (Int_t binx = 1; binx <= nbinsx; ++binx) {
3216 Int_t bin = GetBin(binx,biny,binz);
3217 x[0] = fXaxis.GetBinCenter(binx);
3218 if (range && !f1->IsInside(x)) continue;
3219 Double_t fu = f1->Eval(x[0], x[1], x[2]);
3220 if (stat) fu = gRandom->PoissonD(fu);
3221 AddBinContent(bin, fu);
3222 if (fSumw2.fN) fSumw2.fArray[bin] += TMath::Abs(fu);
3223 }
3224 }
3225 }
3226}
3227
3228////////////////////////////////////////////////////////////////////////////////
3229/// Execute action corresponding to one event.
3230///
3231/// This member function is called when a histogram is clicked with the locator
3232///
3233/// If Left button clicked on the bin top value, then the content of this bin
3234/// is modified according to the new position of the mouse when it is released.
3235
3237{
3238 if (fPainter) fPainter->ExecuteEvent(event, px, py);
3239}
3240
3241////////////////////////////////////////////////////////////////////////////////
3242/// This function allows to do discrete Fourier transforms of TH1 and TH2.
3243/// Available transform types and flags are described below.
3244///
3245/// To extract more information about the transform, use the function
3246/// TVirtualFFT::GetCurrentTransform() to get a pointer to the current
3247/// transform object.
3248///
3249/// \param[out] h_output histogram for the output. If a null pointer is passed, a new histogram is created
3250/// and returned, otherwise, the provided histogram is used and should be big enough
3251/// \param[in] option option parameters consists of 3 parts:
3252/// - option on what to return
3253/// - "RE" - returns a histogram of the real part of the output
3254/// - "IM" - returns a histogram of the imaginary part of the output
3255/// - "MAG"- returns a histogram of the magnitude of the output
3256/// - "PH" - returns a histogram of the phase of the output
3257/// - option of transform type
3258/// - "R2C" - real to complex transforms - default
3259/// - "R2HC" - real to halfcomplex (special format of storing output data,
3260/// results the same as for R2C)
3261/// - "DHT" - discrete Hartley transform
3262/// real to real transforms (sine and cosine):
3263/// - "R2R_0", "R2R_1", "R2R_2", "R2R_3" - discrete cosine transforms of types I-IV
3264/// - "R2R_4", "R2R_5", "R2R_6", "R2R_7" - discrete sine transforms of types I-IV
3265/// To specify the type of each dimension of a 2-dimensional real to real
3266/// transform, use options of form "R2R_XX", for example, "R2R_02" for a transform,
3267/// which is of type "R2R_0" in 1st dimension and "R2R_2" in the 2nd.
3268/// - option of transform flag
3269/// - "ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal
3270/// performance
3271/// - "M" (from "measure") - some time spend in finding the optimal way to do the transform
3272/// - "P" (from "patient") - more time spend in finding the optimal way to do the transform
3273/// - "EX" (from "exhaustive") - the most optimal way is found
3274/// This option should be chosen depending on how many transforms of the same size and
3275/// type are going to be done. Planning is only done once, for the first transform of this
3276/// size and type. Default is "ES".
3277///
3278/// Examples of valid options: "Mag R2C M" "Re R2R_11" "Im R2C ES" "PH R2HC EX"
3279
3280TH1* TH1::FFT(TH1* h_output, Option_t *option)
3281{
3282
3283 Int_t ndim[3];
3284 ndim[0] = this->GetNbinsX();
3285 ndim[1] = this->GetNbinsY();
3286 ndim[2] = this->GetNbinsZ();
3287
3288 TVirtualFFT *fft;
3289 TString opt = option;
3290 opt.ToUpper();
3291 if (!opt.Contains("2R")){
3292 if (!opt.Contains("2C") && !opt.Contains("2HC") && !opt.Contains("DHT")) {
3293 //no type specified, "R2C" by default
3294 opt.Append("R2C");
3295 }
3296 fft = TVirtualFFT::FFT(this->GetDimension(), ndim, opt.Data());
3297 }
3298 else {
3299 //find the kind of transform
3300 Int_t ind = opt.Index("R2R", 3);
3301 Int_t *kind = new Int_t[2];
3302 char t;
3303 t = opt[ind+4];
3304 kind[0] = atoi(&t);
3305 if (h_output->GetDimension()>1) {
3306 t = opt[ind+5];
3307 kind[1] = atoi(&t);
3308 }
3309 fft = TVirtualFFT::SineCosine(this->GetDimension(), ndim, kind, option);
3310 delete [] kind;
3311 }
3312
3313 if (!fft) return 0;
3314 Int_t in=0;
3315 for (Int_t binx = 1; binx<=ndim[0]; binx++) {
3316 for (Int_t biny=1; biny<=ndim[1]; biny++) {
3317 for (Int_t binz=1; binz<=ndim[2]; binz++) {
3318 fft->SetPoint(in, this->GetBinContent(binx, biny, binz));
3319 in++;
3320 }
3321 }
3322 }
3323 fft->Transform();
3324 h_output = TransformHisto(fft, h_output, option);
3325 return h_output;
3326}
3327
3328////////////////////////////////////////////////////////////////////////////////
3329/// Increment bin with abscissa X by 1.
3330///
3331/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3332/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3333///
3334/// If the storage of the sum of squares of weights has been triggered,
3335/// via the function Sumw2, then the sum of the squares of weights is incremented
3336/// by 1 in the bin corresponding to x.
3337///
3338/// The function returns the corresponding bin number which has its content incremented by 1
3339
3341{
3342 if (fBuffer) return BufferFill(x,1);
3343
3344 Int_t bin;
3345 fEntries++;
3346 bin =fXaxis.FindBin(x);
3347 if (bin <0) return -1;
3348 AddBinContent(bin);
3349 if (fSumw2.fN) ++fSumw2.fArray[bin];
3350 if (bin == 0 || bin > fXaxis.GetNbins()) {
3351 if (!GetStatOverflowsBehaviour()) return -1;
3352 }
3353 ++fTsumw;
3354 ++fTsumw2;
3355 fTsumwx += x;
3356 fTsumwx2 += x*x;
3357 return bin;
3358}
3359
3360////////////////////////////////////////////////////////////////////////////////
3361/// Increment bin with abscissa X with a weight w.
3362///
3363/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3364/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3365///
3366/// If the weight is not equal to 1, the storage of the sum of squares of
3367/// weights is automatically triggered and the sum of the squares of weights is incremented
3368/// by \f$ w^2 \f$ in the bin corresponding to x.
3369///
3370/// The function returns the corresponding bin number which has its content incremented by w
3371
3373{
3374
3375 if (fBuffer) return BufferFill(x,w);
3376
3377 Int_t bin;
3378 fEntries++;
3379 bin =fXaxis.FindBin(x);
3380 if (bin <0) return -1;
3381 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW) ) Sumw2(); // must be called before AddBinContent
3382 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3383 AddBinContent(bin, w);
3384 if (bin == 0 || bin > fXaxis.GetNbins()) {
3385 if (!GetStatOverflowsBehaviour()) return -1;
3386 }
3387 Double_t z= w;
3388 fTsumw += z;
3389 fTsumw2 += z*z;
3390 fTsumwx += z*x;
3391 fTsumwx2 += z*x*x;
3392 return bin;
3393}
3394
3395////////////////////////////////////////////////////////////////////////////////
3396/// Increment bin with namex with a weight w
3397///
3398/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3399/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3400///
3401/// If the weight is not equal to 1, the storage of the sum of squares of
3402/// weights is automatically triggered and the sum of the squares of weights is incremented
3403/// by \f$ w^2 \f$ in the bin corresponding to x.
3404///
3405/// The function returns the corresponding bin number which has its content
3406/// incremented by w.
3407
3408Int_t TH1::Fill(const char *namex, Double_t w)
3409{
3410 Int_t bin;
3411 fEntries++;
3412 bin =fXaxis.FindBin(namex);
3413 if (bin <0) return -1;
3414 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3415 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3416 AddBinContent(bin, w);
3417 if (bin == 0 || bin > fXaxis.GetNbins()) return -1;
3418 Double_t z= w;
3419 fTsumw += z;
3420 fTsumw2 += z*z;
3421 // this make sense if the histogram is not expanding (the x axis cannot be extended)
3422 if (!fXaxis.CanExtend() || !fXaxis.IsAlphanumeric()) {
3424 fTsumwx += z*x;
3425 fTsumwx2 += z*x*x;
3426 }
3427 return bin;
3428}
3429
3430////////////////////////////////////////////////////////////////////////////////
3431/// Fill this histogram with an array x and weights w.
3432///
3433/// \param[in] ntimes number of entries in arrays x and w (array size must be ntimes*stride)
3434/// \param[in] x array of values to be histogrammed
3435/// \param[in] w array of weighs
3436/// \param[in] stride step size through arrays x and w
3437///
3438/// If the weight is not equal to 1, the storage of the sum of squares of
3439/// weights is automatically triggered and the sum of the squares of weights is incremented
3440/// by \f$ w^2 \f$ in the bin corresponding to x.
3441/// if w is NULL each entry is assumed a weight=1
3442
3443void TH1::FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3444{
3445 //If a buffer is activated, fill buffer
3446 if (fBuffer) {
3447 ntimes *= stride;
3448 Int_t i = 0;
3449 for (i=0;i<ntimes;i+=stride) {
3450 if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty
3451 if (w) BufferFill(x[i],w[i]);
3452 else BufferFill(x[i], 1.);
3453 }
3454 // fill the remaining entries if the buffer has been deleted
3455 if (i < ntimes && !fBuffer) {
3456 auto weights = w ? &w[i] : nullptr;
3457 DoFillN((ntimes-i)/stride,&x[i],weights,stride);
3458 }
3459 return;
3460 }
3461 // call internal method
3462 DoFillN(ntimes, x, w, stride);
3463}
3464
3465////////////////////////////////////////////////////////////////////////////////
3466/// Internal method to fill histogram content from a vector
3467/// called directly by TH1::BufferEmpty
3468
3469void TH1::DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3470{
3471 Int_t bin,i;
3472
3473 fEntries += ntimes;
3474 Double_t ww = 1;
3475 Int_t nbins = fXaxis.GetNbins();
3476 ntimes *= stride;
3477 for (i=0;i<ntimes;i+=stride) {
3478 bin =fXaxis.FindBin(x[i]);
3479 if (bin <0) continue;
3480 if (w) ww = w[i];
3481 if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3482 if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
3483 AddBinContent(bin, ww);
3484 if (bin == 0 || bin > nbins) {
3485 if (!GetStatOverflowsBehaviour()) continue;
3486 }
3487 Double_t z= ww;
3488 fTsumw += z;
3489 fTsumw2 += z*z;
3490 fTsumwx += z*x[i];
3491 fTsumwx2 += z*x[i]*x[i];
3492 }
3493}
3494
3495////////////////////////////////////////////////////////////////////////////////
3496/// Fill histogram following distribution in function fname.
3497///
3498/// @param fname : Function name used for filling the histogram
3499/// @param ntimes : number of times the histogram is filled
3500/// @param rng : (optional) Random number generator used to sample
3501///
3502///
3503/// The distribution contained in the function fname (TF1) is integrated
3504/// over the channel contents for the bin range of this histogram.
3505/// It is normalized to 1.
3506///
3507/// Getting one random number implies:
3508/// - Generating a random number between 0 and 1 (say r1)
3509/// - Look in which bin in the normalized integral r1 corresponds to
3510/// - Fill histogram channel
3511/// ntimes random numbers are generated
3512///
3513/// One can also call TF1::GetRandom to get a random variate from a function.
3514
3515void TH1::FillRandom(const char *fname, Int_t ntimes, TRandom * rng)
3516{
3517 Int_t bin, binx, ibin, loop;
3518 Double_t r1, x;
3519 // - Search for fname in the list of ROOT defined functions
3520 TF1 *f1 = (TF1*)gROOT->GetFunction(fname);
3521 if (!f1) { Error("FillRandom", "Unknown function: %s",fname); return; }
3522
3523 // - Allocate temporary space to store the integral and compute integral
3524
3525 TAxis * xAxis = &fXaxis;
3526
3527 // in case axis of histogram is not defined use the function axis
3528 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
3530 f1->GetRange(xmin,xmax);
3531 Info("FillRandom","Using function axis and range [%g,%g]",xmin, xmax);
3532 xAxis = f1->GetHistogram()->GetXaxis();
3533 }
3534
3535 Int_t first = xAxis->GetFirst();
3536 Int_t last = xAxis->GetLast();
3537 Int_t nbinsx = last-first+1;
3538
3539 Double_t *integral = new Double_t[nbinsx+1];
3540 integral[0] = 0;
3541 for (binx=1;binx<=nbinsx;binx++) {
3542 Double_t fint = f1->Integral(xAxis->GetBinLowEdge(binx+first-1),xAxis->GetBinUpEdge(binx+first-1), 0.);
3543 integral[binx] = integral[binx-1] + fint;
3544 }
3545
3546 // - Normalize integral to 1
3547 if (integral[nbinsx] == 0 ) {
3548 delete [] integral;
3549 Error("FillRandom", "Integral = zero"); return;
3550 }
3551 for (bin=1;bin<=nbinsx;bin++) integral[bin] /= integral[nbinsx];
3552
3553 // --------------Start main loop ntimes
3554 for (loop=0;loop<ntimes;loop++) {
3555 r1 = (rng) ? rng->Rndm() : gRandom->Rndm();
3556 ibin = TMath::BinarySearch(nbinsx,&integral[0],r1);
3557 //binx = 1 + ibin;
3558 //x = xAxis->GetBinCenter(binx); //this is not OK when SetBuffer is used
3559 x = xAxis->GetBinLowEdge(ibin+first)
3560 +xAxis->GetBinWidth(ibin+first)*(r1-integral[ibin])/(integral[ibin+1] - integral[ibin]);
3561 Fill(x);
3562 }
3563 delete [] integral;
3564}
3565
3566////////////////////////////////////////////////////////////////////////////////
3567/// Fill histogram following distribution in histogram h.
3568///
3569/// @param h : Histogram pointer used for sampling random number
3570/// @param ntimes : number of times the histogram is filled
3571/// @param rng : (optional) Random number generator used for sampling
3572///
3573/// The distribution contained in the histogram h (TH1) is integrated
3574/// over the channel contents for the bin range of this histogram.
3575/// It is normalized to 1.
3576///
3577/// Getting one random number implies:
3578/// - Generating a random number between 0 and 1 (say r1)
3579/// - Look in which bin in the normalized integral r1 corresponds to
3580/// - Fill histogram channel ntimes random numbers are generated
3581///
3582/// SPECIAL CASE when the target histogram has the same binning as the source.
3583/// in this case we simply use a poisson distribution where
3584/// the mean value per bin = bincontent/integral.
3585
3586void TH1::FillRandom(TH1 *h, Int_t ntimes, TRandom * rng)
3587{
3588 if (!h) { Error("FillRandom", "Null histogram"); return; }
3589 if (fDimension != h->GetDimension()) {
3590 Error("FillRandom", "Histograms with different dimensions"); return;
3591 }
3592 if (std::isnan(h->ComputeIntegral(true))) {
3593 Error("FillRandom", "Histograms contains negative bins, does not represent probabilities");
3594 return;
3595 }
3596
3597 //in case the target histogram has the same binning and ntimes much greater
3598 //than the number of bins we can use a fast method
3600 Int_t last = fXaxis.GetLast();
3601 Int_t nbins = last-first+1;
3602 if (ntimes > 10*nbins) {
3603 try {
3604 CheckConsistency(this,h);
3605 Double_t sumw = h->Integral(first,last);
3606 if (sumw == 0) return;
3607 Double_t sumgen = 0;
3608 for (Int_t bin=first;bin<=last;bin++) {
3609 Double_t mean = h->RetrieveBinContent(bin)*ntimes/sumw;
3610 Double_t cont = (rng) ? rng->Poisson(mean) : gRandom->Poisson(mean);
3611 sumgen += cont;
3612 AddBinContent(bin,cont);
3613 if (fSumw2.fN) fSumw2.fArray[bin] += cont;
3614 }
3615
3616 // fix for the fluctuations in the total number n
3617 // since we use Poisson instead of multinomial
3618 // add a correction to have ntimes as generated entries
3619 Int_t i;
3620 if (sumgen < ntimes) {
3621 // add missing entries
3622 for (i = Int_t(sumgen+0.5); i < ntimes; ++i)
3623 {
3624 Double_t x = h->GetRandom();
3625 Fill(x);
3626 }
3627 }
3628 else if (sumgen > ntimes) {
3629 // remove extra entries
3630 i = Int_t(sumgen+0.5);
3631 while( i > ntimes) {
3632 Double_t x = h->GetRandom(rng);
3633 Int_t ibin = fXaxis.FindBin(x);
3635 // skip in case bin is empty
3636 if (y > 0) {
3637 SetBinContent(ibin, y-1.);
3638 i--;
3639 }
3640 }
3641 }
3642
3643 ResetStats();
3644 return;
3645 }
3646 catch(std::exception&) {} // do nothing
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 0;
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 0;
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 == 0) {
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 (