Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TH1.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Rene Brun 26/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include <array>
13#include <cctype>
14#include <climits>
15#include <cmath>
16#include <cstdio>
17#include <cstdlib>
18#include <cstring>
19#include <iostream>
20#include <sstream>
21#include <fstream>
22
23#include "TROOT.h"
24#include "TBuffer.h"
25#include "TEnv.h"
26#include "TClass.h"
27#include "TMath.h"
28#include "THashList.h"
29#include "TH1.h"
30#include "TH2.h"
31#include "TH3.h"
32#include "TF2.h"
33#include "TF3.h"
34#include "TPluginManager.h"
35#include "TVirtualPad.h"
36#include "TRandom.h"
37#include "TVirtualFitter.h"
38#include "THLimitsFinder.h"
39#include "TProfile.h"
40#include "TStyle.h"
41#include "TVectorF.h"
42#include "TVectorD.h"
43#include "TBrowser.h"
44#include "TError.h"
45#include "TVirtualHistPainter.h"
46#include "TVirtualFFT.h"
47#include "TVirtualPaveStats.h"
48
49#include "HFitInterface.h"
50#include "Fit/DataRange.h"
51#include "Fit/BinData.h"
52#include "Math/GoFTest.h"
55
56#include "TH1Merger.h"
57
58/** \addtogroup Histograms
59@{
60\class TH1C
61\brief 1-D histogram with a byte per channel (see TH1 documentation)
62\class TH1S
63\brief 1-D histogram with a short per channel (see TH1 documentation)
64\class TH1I
65\brief 1-D histogram with an int per channel (see TH1 documentation)
66\class TH1L
67\brief 1-D histogram with a long64 per channel (see TH1 documentation)
68\class TH1F
69\brief 1-D histogram with a float per channel (see TH1 documentation)
70\class TH1D
71\brief 1-D histogram with a double per channel (see TH1 documentation)
72@}
73*/
74
75/** \class TH1
76 \ingroup Histograms
77TH1 is the base class of all histogram classes in %ROOT.
78
79It provides the common interface for operations such as binning, filling, drawing, which
80will be detailed below.
81
82-# [Creating histograms](\ref creating-histograms)
83 - [Labelling axes](\ref labelling-axis)
84-# [Binning](\ref binning)
85 - [Fix or variable bin size](\ref fix-var)
86 - [Convention for numbering bins](\ref convention)
87 - [Alphanumeric Bin Labels](\ref alpha)
88 - [Histograms with automatic bins](\ref auto-bin)
89 - [Rebinning](\ref rebinning)
90-# [Filling histograms](\ref filling-histograms)
91 - [Associated errors](\ref associated-errors)
92 - [Associated functions](\ref associated-functions)
93 - [Projections of histograms](\ref prof-hist)
94 - [Random Numbers and histograms](\ref random-numbers)
95 - [Making a copy of a histogram](\ref making-a-copy)
96 - [Normalizing histograms](\ref normalizing)
97-# [Drawing histograms](\ref drawing-histograms)
98 - [Setting Drawing histogram contour levels (2-D hists only)](\ref cont-level)
99 - [Setting histogram graphics attributes](\ref graph-att)
100 - [Customising how axes are drawn](\ref axis-drawing)
101-# [Fitting histograms](\ref fitting-histograms)
102-# [Saving/reading histograms to/from a ROOT file](\ref saving-histograms)
103-# [Operations on histograms](\ref operations-on-histograms)
104-# [Miscellaneous operations](\ref misc)
105
106ROOT supports the following histogram types:
107
108 - 1-D histograms:
109 - TH1C : histograms with one byte per channel. Maximum bin content = 127
110 - TH1S : histograms with one short per channel. Maximum bin content = 32767
111 - TH1I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
112 - TH1L : histograms with one long64 per channel. Maximum bin content = LLONG_MAX (\ref llongmax "**")
113 - TH1F : histograms with one float per channel. Maximum precision 7 digits, maximum integer bin content = +/-16777216 (\ref floatmax "***")
114 - TH1D : histograms with one double per channel. Maximum precision 14 digits, maximum integer bin content = +/-9007199254740992 (\ref doublemax "****")
115 - 2-D histograms:
116 - TH2C : histograms with one byte per channel. Maximum bin content = 127
117 - TH2S : histograms with one short per channel. Maximum bin content = 32767
118 - TH2I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
119 - TH2L : histograms with one long64 per channel. Maximum bin content = LLONG_MAX (\ref llongmax "**")
120 - TH2F : histograms with one float per channel. Maximum precision 7 digits, maximum integer bin content = +/-16777216 (\ref floatmax "***")
121 - TH2D : histograms with one double per channel. Maximum precision 14 digits, maximum integer bin content = +/-9007199254740992 (\ref doublemax "****")
122 - 3-D histograms:
123 - TH3C : histograms with one byte per channel. Maximum bin content = 127
124 - TH3S : histograms with one short per channel. Maximum bin content = 32767
125 - TH3I : histograms with one int per channel. Maximum bin content = INT_MAX (\ref intmax "*")
126 - TH3L : histograms with one long64 per channel. Maximum bin content = LLONG_MAX (\ref llongmax "**")
127 - TH3F : histograms with one float per channel. Maximum precision 7 digits, maximum integer bin content = +/-16777216 (\ref floatmax "***")
128 - TH3D : histograms with one double per channel. Maximum precision 14 digits, maximum integer bin content = +/-9007199254740992 (\ref doublemax "****")
129 - Profile histograms: See classes TProfile, TProfile2D and TProfile3D.
130 Profile histograms are used to display the mean value of Y and its standard deviation
131 for each bin in X. Profile histograms are in many cases an elegant
132 replacement of two-dimensional histograms : the inter-relation of two
133 measured quantities X and Y can always be visualized by a two-dimensional
134 histogram or scatter-plot; If Y is an unknown (but single-valued)
135 approximate function of X, this function is displayed by a profile
136 histogram with much better precision than by a scatter-plot.
137
138<sup>
139\anchor intmax (*) INT_MAX = 2147483647 is the [maximum value for a variable of type int.](https://docs.microsoft.com/en-us/cpp/c-language/cpp-integer-limits)<br>
140\anchor llongmax (**) LLONG_MAX = 9223372036854775807 is the [maximum value for a variable of type long64.](https://docs.microsoft.com/en-us/cpp/c-language/cpp-integer-limits)<br>
141\anchor floatmax (***) 2^24 = 16777216 is the [maximum integer that can be properly represented by a float32 with 23-bit mantissa.](https://stackoverflow.com/a/3793950/7471760)<br>
142\anchor doublemax (****) 2^53 = 9007199254740992 is the [maximum integer that can be properly represented by a double64 with 52-bit mantissa.](https://stackoverflow.com/a/3793950/7471760)
143</sup>
144
145The inheritance hierarchy looks as follows:
146
147\image html classTH1__inherit__graph_org.svg width=100%
148
149\anchor creating-histograms
150## Creating histograms
151
152Histograms are created by invoking one of the constructors, e.g.
153~~~ {.cpp}
154 TH1F *h1 = new TH1F("h1", "h1 title", 100, 0, 4.4);
155 TH2F *h2 = new TH2F("h2", "h2 title", 40, 0, 4, 30, -3, 3);
156~~~
157Histograms may also be created by:
158
159 - calling the Clone() function, see below
160 - making a projection from a 2-D or 3-D histogram, see below
161 - reading a histogram from a file
162
163 When a histogram is created, a reference to it is automatically added
164 to the list of in-memory objects for the current file or directory.
165 Then the pointer to this histogram in the current directory can be found
166 by its name, doing:
167~~~ {.cpp}
168 TH1F *h1 = (TH1F*)gDirectory->FindObject(name);
169~~~
170
171 This default behaviour can be changed by:
172~~~ {.cpp}
173 h->SetDirectory(nullptr); // for the current histogram h
174 TH1::AddDirectory(kFALSE); // sets a global switch disabling the referencing
175~~~
176 When the histogram is deleted, the reference to it is removed from
177 the list of objects in memory.
178 When a file is closed, all histograms in memory associated with this file
179 are automatically deleted.
180
181\anchor labelling-axis
182### Labelling axes
183
184 Axis titles can be specified in the title argument of the constructor.
185 They must be separated by ";":
186~~~ {.cpp}
187 TH1F* h=new TH1F("h", "Histogram title;X Axis;Y Axis", 100, 0, 1);
188~~~
189 The histogram title and the axis titles can be any TLatex string, and
190 are persisted if a histogram is written to a file.
191
192 Any title can be omitted:
193~~~ {.cpp}
194 TH1F* h=new TH1F("h", "Histogram title;;Y Axis", 100, 0, 1);
195 TH1F* h=new TH1F("h", ";;Y Axis", 100, 0, 1);
196~~~
197 The method SetTitle() has the same syntax:
198~~~ {.cpp}
199 h->SetTitle("Histogram title;Another X title Axis");
200~~~
201Alternatively, the title of each axis can be set directly:
202~~~ {.cpp}
203 h->GetXaxis()->SetTitle("X axis title");
204 h->GetYaxis()->SetTitle("Y axis title");
205~~~
206For bin labels see \ref binning.
207
208\anchor binning
209## Binning
210
211\anchor fix-var
212### Fix or variable bin size
213
214 All histogram types support either fix or variable bin sizes.
215 2-D histograms may have fix size bins along X and variable size bins
216 along Y or vice-versa. The functions to fill, manipulate, draw or access
217 histograms are identical in both cases.
218
219 Each histogram always contains 3 axis objects of type TAxis: fXaxis, fYaxis and fZaxis.
220 To access the axis parameters, use:
221~~~ {.cpp}
222 TAxis *xaxis = h->GetXaxis(); etc.
223 Double_t binCenter = xaxis->GetBinCenter(bin), etc.
224~~~
225 See class TAxis for a description of all the access functions.
226 The axis range is always stored internally in double precision.
227
228\anchor convention
229### Convention for numbering bins
230
231 For all histogram types: nbins, xlow, xup
232~~~ {.cpp}
233 bin = 0; underflow bin
234 bin = 1; first bin with low-edge xlow INCLUDED
235 bin = nbins; last bin with upper-edge xup EXCLUDED
236 bin = nbins+1; overflow bin
237~~~
238 In case of 2-D or 3-D histograms, a "global bin" number is defined.
239 For example, assuming a 3-D histogram with (binx, biny, binz), the function
240~~~ {.cpp}
241 Int_t gbin = h->GetBin(binx, biny, binz);
242~~~
243 returns a global/linearized gbin number. This global gbin is useful
244 to access the bin content/error information independently of the dimension.
245 Note that to access the information other than bin content and errors
246 one should use the TAxis object directly with e.g.:
247~~~ {.cpp}
248 Double_t xcenter = h3->GetZaxis()->GetBinCenter(27);
249~~~
250 returns the center along z of bin number 27 (not the global bin)
251 in the 3-D histogram h3.
252
253\anchor alpha
254### Alphanumeric Bin Labels
255
256 By default, a histogram axis is drawn with its numeric bin labels.
257 One can specify alphanumeric labels instead with:
258
259 - call TAxis::SetBinLabel(bin, label);
260 This can always be done before or after filling.
261 When the histogram is drawn, bin labels will be automatically drawn.
262 See examples labels1.C and labels2.C
263 - call to a Fill function with one of the arguments being a string, e.g.
264~~~ {.cpp}
265 hist1->Fill(somename, weight);
266 hist2->Fill(x, somename, weight);
267 hist2->Fill(somename, y, weight);
268 hist2->Fill(somenamex, somenamey, weight);
269~~~
270 See examples hlabels1.C and hlabels2.C
271 - via TTree::Draw. see for example cernstaff.C
272~~~ {.cpp}
273 tree.Draw("Nation::Division");
274~~~
275 where "Nation" and "Division" are two branches of a Tree.
276
277When using the options 2 or 3 above, the labels are automatically
278 added to the list (THashList) of labels for a given axis.
279 By default, an axis is drawn with the order of bins corresponding
280 to the filling sequence. It is possible to reorder the axis
281
282 - alphabetically
283 - by increasing or decreasing values
284
285 The reordering can be triggered via the TAxis context menu by selecting
286 the menu item "LabelsOption" or by calling directly
287 TH1::LabelsOption(option, axis) where
288
289 - axis may be "X", "Y" or "Z"
290 - option may be:
291 - "a" sort by alphabetic order
292 - ">" sort by decreasing values
293 - "<" sort by increasing values
294 - "h" draw labels horizontal
295 - "v" draw labels vertical
296 - "u" draw labels up (end of label right adjusted)
297 - "d" draw labels down (start of label left adjusted)
298
299 When using the option 2 above, new labels are added by doubling the current
300 number of bins in case one label does not exist yet.
301 When the Filling is terminated, it is possible to trim the number
302 of bins to match the number of active labels by calling
303~~~ {.cpp}
304 TH1::LabelsDeflate(axis) with axis = "X", "Y" or "Z"
305~~~
306 This operation is automatic when using TTree::Draw.
307 Once bin labels have been created, they become persistent if the histogram
308 is written to a file or when generating the C++ code via SavePrimitive.
309
310\anchor auto-bin
311### Histograms with automatic bins
312
313 When a histogram is created with an axis lower limit greater or equal
314 to its upper limit, the SetBuffer is automatically called with an
315 argument fBufferSize equal to fgBufferSize (default value=1000).
316 fgBufferSize may be reset via the static function TH1::SetDefaultBufferSize.
317 The axis limits will be automatically computed when the buffer will
318 be full or when the function BufferEmpty is called.
319
320\anchor rebinning
321### Rebinning
322
323 At any time, a histogram can be rebinned via TH1::Rebin. This function
324 returns a new histogram with the rebinned contents.
325 If bin errors were stored, they are recomputed during the rebinning.
326
327
328\anchor filling-histograms
329## Filling histograms
331 A histogram is typically filled with statements like:
332~~~ {.cpp}
333 h1->Fill(x);
334 h1->Fill(x, w); //fill with weight
335 h2->Fill(x, y)
336 h2->Fill(x, y, w)
337 h3->Fill(x, y, z)
338 h3->Fill(x, y, z, w)
339~~~
340 or via one of the Fill functions accepting names described above.
341 The Fill functions compute the bin number corresponding to the given
342 x, y or z argument and increment this bin by the given weight.
343 The Fill functions return the bin number for 1-D histograms or global
344 bin number for 2-D and 3-D histograms.
345 If TH1::Sumw2 has been called before filling, the sum of squares of
346 weights is also stored.
347 One can also increment directly a bin number via TH1::AddBinContent
348 or replace the existing content via TH1::SetBinContent. Passing an
349 out-of-range bin to TH1::AddBinContent leads to undefined behavior.
350 To access the bin content of a given bin, do:
351~~~ {.cpp}
352 Double_t binContent = h->GetBinContent(bin);
353~~~
354
355 By default, the bin number is computed using the current axis ranges.
356 If the automatic binning option has been set via
357~~~ {.cpp}
358 h->SetCanExtend(TH1::kAllAxes);
359~~~
360 then, the Fill Function will automatically extend the axis range to
361 accomodate the new value specified in the Fill argument. The method
362 used is to double the bin size until the new value fits in the range,
363 merging bins two by two. This automatic binning options is extensively
364 used by the TTree::Draw function when histogramming Tree variables
365 with an unknown range.
366 This automatic binning option is supported for 1-D, 2-D and 3-D histograms.
367
368 During filling, some statistics parameters are incremented to compute
369 the mean value and Root Mean Square with the maximum precision.
370
371 In case of histograms of type TH1C, TH1S, TH2C, TH2S, TH3C, TH3S
372 a check is made that the bin contents do not exceed the maximum positive
373 capacity (127 or 32767). Histograms of all types may have positive
374 or/and negative bin contents.
375
376\anchor associated-errors
377### Associated errors
378 By default, for each bin, the sum of weights is computed at fill time.
379 One can also call TH1::Sumw2 to force the storage and computation
380 of the sum of the square of weights per bin.
381 If Sumw2 has been called, the error per bin is computed as the
382 sqrt(sum of squares of weights), otherwise the error is set equal
383 to the sqrt(bin content).
384 To return the error for a given bin number, do:
385~~~ {.cpp}
386 Double_t error = h->GetBinError(bin);
387~~~
388
389\anchor associated-functions
390### Associated functions
391 One or more object (typically a TF1*) can be added to the list
392 of functions (fFunctions) associated to each histogram.
393 When TH1::Fit is invoked, the fitted function is added to this list.
394 Given a histogram h, one can retrieve an associated function
395 with:
396~~~ {.cpp}
397 TF1 *myfunc = h->GetFunction("myfunc");
398~~~
399
400
401\anchor operations-on-histograms
402## Operations on histograms
403
404 Many types of operations are supported on histograms or between histograms
405
406 - Addition of a histogram to the current histogram.
407 - Additions of two histograms with coefficients and storage into the current
408 histogram.
409 - Multiplications and Divisions are supported in the same way as additions.
410 - The Add, Divide and Multiply functions also exist to add, divide or multiply
411 a histogram by a function.
412
413 If a histogram has associated error bars (TH1::Sumw2 has been called),
414 the resulting error bars are also computed assuming independent histograms.
415 In case of divisions, Binomial errors are also supported.
416 One can mark a histogram to be an "average" histogram by setting its bit kIsAverage via
417 myhist.SetBit(TH1::kIsAverage);
418 When adding (see TH1::Add) average histograms, the histograms are averaged and not summed.
419
420
421\anchor prof-hist
422### Projections of histograms
423
424 One can:
425
426 - make a 1-D projection of a 2-D histogram or Profile
427 see functions TH2::ProjectionX,Y, TH2::ProfileX,Y, TProfile::ProjectionX
428 - make a 1-D, 2-D or profile out of a 3-D histogram
429 see functions TH3::ProjectionZ, TH3::Project3D.
430
431 One can fit these projections via:
432~~~ {.cpp}
433 TH2::FitSlicesX,Y, TH3::FitSlicesZ.
434~~~
435
436\anchor random-numbers
437### Random Numbers and histograms
438
439 TH1::FillRandom can be used to randomly fill a histogram using
440 the contents of an existing TF1 function or another
441 TH1 histogram (for all dimensions).
442 For example, the following two statements create and fill a histogram
443 10000 times with a default gaussian distribution of mean 0 and sigma 1:
444~~~ {.cpp}
445 TH1F h1("h1", "histo from a gaussian", 100, -3, 3);
446 h1.FillRandom("gaus", 10000);
447~~~
448 TH1::GetRandom can be used to return a random number distributed
449 according to the contents of a histogram.
450
451\anchor making-a-copy
452### Making a copy of a histogram
453 Like for any other ROOT object derived from TObject, one can use
454 the Clone() function. This makes an identical copy of the original
455 histogram including all associated errors and functions, e.g.:
456~~~ {.cpp}
457 TH1F *hnew = (TH1F*)h->Clone("hnew");
458~~~
459
460\anchor normalizing
461### Normalizing histograms
462
463 One can scale a histogram such that the bins integral is equal to
464 the normalization parameter via TH1::Scale(Double_t norm), where norm
465 is the desired normalization divided by the integral of the histogram.
466
467
468\anchor drawing-histograms
469## Drawing histograms
470
471 Histograms are drawn via the THistPainter class. Each histogram has
472 a pointer to its own painter (to be usable in a multithreaded program).
473 Many drawing options are supported.
474 See THistPainter::Paint() for more details.
475
476 The same histogram can be drawn with different options in different pads.
477 When a histogram drawn in a pad is deleted, the histogram is
478 automatically removed from the pad or pads where it was drawn.
479 If a histogram is drawn in a pad, then filled again, the new status
480 of the histogram will be automatically shown in the pad next time
481 the pad is updated. One does not need to redraw the histogram.
482 To draw the current version of a histogram in a pad, one can use
483~~~ {.cpp}
484 h->DrawCopy();
485~~~
486 This makes a clone (see Clone below) of the histogram. Once the clone
487 is drawn, the original histogram may be modified or deleted without
488 affecting the aspect of the clone.
489
490 One can use TH1::SetMaximum() and TH1::SetMinimum() to force a particular
491 value for the maximum or the minimum scale on the plot. (For 1-D
492 histograms this means the y-axis, while for 2-D histograms these
493 functions affect the z-axis).
494
495 TH1::UseCurrentStyle() can be used to change all histogram graphics
496 attributes to correspond to the current selected style.
497 This function must be called for each histogram.
498 In case one reads and draws many histograms from a file, one can force
499 the histograms to inherit automatically the current graphics style
500 by calling before gROOT->ForceStyle().
501
502\anchor cont-level
503### Setting Drawing histogram contour levels (2-D hists only)
504
505 By default contours are automatically generated at equidistant
506 intervals. A default value of 20 levels is used. This can be modified
507 via TH1::SetContour() or TH1::SetContourLevel().
508 the contours level info is used by the drawing options "cont", "surf",
509 and "lego".
510
511\anchor graph-att
512### Setting histogram graphics attributes
513
514 The histogram classes inherit from the attribute classes:
515 TAttLine, TAttFill, and TAttMarker.
516 See the member functions of these classes for the list of options.
517
518\anchor axis-drawing
519### Customizing how axes are drawn
520
521 Use the functions of TAxis, such as
522~~~ {.cpp}
523 histogram.GetXaxis()->SetTicks("+");
524 histogram.GetYaxis()->SetRangeUser(1., 5.);
525~~~
526
527\anchor fitting-histograms
528## Fitting histograms
529
530 Histograms (1-D, 2-D, 3-D and Profiles) can be fitted with a user
531 specified function or a pre-defined function via TH1::Fit.
532 See TH1::Fit(TF1*, Option_t *, Option_t *, Double_t, Double_t) for the fitting documentation and the possible [fitting options](\ref HFitOpt)
533
534 The FitPanel can also be used for fitting an histogram. See the [FitPanel documentation](https://root.cern/manual/fitting/#using-the-fit-panel).
535
536\anchor saving-histograms
537## Saving/reading histograms to/from a ROOT file
538
539 The following statements create a ROOT file and store a histogram
540 on the file. Because TH1 derives from TNamed, the key identifier on
541 the file is the histogram name:
542~~~ {.cpp}
543 TFile f("histos.root", "new");
544 TH1F h1("hgaus", "histo from a gaussian", 100, -3, 3);
545 h1.FillRandom("gaus", 10000);
546 h1->Write();
547~~~
548 To read this histogram in another Root session, do:
549~~~ {.cpp}
550 TFile f("histos.root");
551 TH1F *h = (TH1F*)f.Get("hgaus");
552~~~
553 One can save all histograms in memory to the file by:
554~~~ {.cpp}
555 file->Write();
556~~~
557
558
559\anchor misc
560## Miscellaneous operations
561
562~~~ {.cpp}
563 TH1::KolmogorovTest(): statistical test of compatibility in shape
564 between two histograms
565 TH1::Smooth() smooths the bin contents of a 1-d histogram
566 TH1::Integral() returns the integral of bin contents in a given bin range
567 TH1::GetMean(int axis) returns the mean value along axis
568 TH1::GetStdDev(int axis) returns the sigma distribution along axis
569 TH1::GetEntries() returns the number of entries
570 TH1::Reset() resets the bin contents and errors of a histogram
571~~~
572 IMPORTANT NOTE: The returned values for GetMean and GetStdDev depend on how the
573 histogram statistics are calculated. By default, if no range has been set, the
574 returned values are the (unbinned) ones calculated at fill time. If a range has been
575 set, however, the values are calculated using the bins in range; THIS IS TRUE EVEN
576 IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset the range.
577 To ensure that the returned values are always those of the binned data stored in the
578 histogram, call TH1::ResetStats. See TH1::GetStats.
579*/
580
581TF1 *gF1=nullptr; //left for back compatibility (use TVirtualFitter::GetUserFunc instead)
582
587
588extern void H1InitGaus();
589extern void H1InitExpo();
590extern void H1InitPolynom();
591extern void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a);
592extern void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail);
593extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b);
594
595namespace {
596
597/// Enumeration specifying inconsistencies between two histograms,
598/// in increasing severity.
599enum EInconsistencyBits {
600 kFullyConsistent = 0,
601 kDifferentLabels = BIT(0),
602 kDifferentBinLimits = BIT(1),
603 kDifferentAxisLimits = BIT(2),
604 kDifferentNumberOfBins = BIT(3),
605 kDifferentDimensions = BIT(4)
606};
607
608} // namespace
609
611
612////////////////////////////////////////////////////////////////////////////////
613/// Histogram default constructor.
614
616{
617 fDirectory = nullptr;
618 fFunctions = new TList;
619 fNcells = 0;
620 fIntegral = nullptr;
621 fPainter = nullptr;
622 fEntries = 0;
623 fNormFactor = 0;
625 fMaximum = -1111;
626 fMinimum = -1111;
627 fBufferSize = 0;
628 fBuffer = nullptr;
631 fXaxis.SetName("xaxis");
632 fYaxis.SetName("yaxis");
633 fZaxis.SetName("zaxis");
634 fXaxis.SetParent(this);
635 fYaxis.SetParent(this);
636 fZaxis.SetParent(this);
638}
639
640////////////////////////////////////////////////////////////////////////////////
641/// Histogram default destructor.
642
644{
646 return;
647 }
648 delete[] fIntegral;
649 fIntegral = nullptr;
650 delete[] fBuffer;
651 fBuffer = nullptr;
652 if (fFunctions) {
654
656 TObject* obj = nullptr;
657 //special logic to support the case where the same object is
658 //added multiple times in fFunctions.
659 //This case happens when the same object is added with different
660 //drawing modes
661 //In the loop below we must be careful with objects (eg TCutG) that may
662 // have been added to the list of functions of several histograms
663 //and may have been already deleted.
664 while ((obj = fFunctions->First())) {
665 while(fFunctions->Remove(obj)) { }
667 break;
668 }
669 delete obj;
670 obj = nullptr;
671 }
672 delete fFunctions;
673 fFunctions = nullptr;
674 }
675 if (fDirectory) {
676 fDirectory->Remove(this);
677 fDirectory = nullptr;
678 }
679 delete fPainter;
680 fPainter = nullptr;
681}
682
683////////////////////////////////////////////////////////////////////////////////
684/// Constructor for fix bin size histograms.
685/// Creates the main histogram structure.
686///
687/// \param[in] name name of histogram (avoid blanks)
688/// \param[in] title histogram title.
689/// If title is of the form `stringt;stringx;stringy;stringz`,
690/// the histogram title is set to `stringt`,
691/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
692/// \param[in] nbins number of bins
693/// \param[in] xlow low edge of first bin
694/// \param[in] xup upper edge of last bin (not included in last bin)
695
696
697TH1::TH1(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
698 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
699{
700 Build();
701 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
702 fXaxis.Set(nbins,xlow,xup);
703 fNcells = fXaxis.GetNbins()+2;
704}
705
706////////////////////////////////////////////////////////////////////////////////
707/// Constructor for variable bin size histograms using an input array of type float.
708/// Creates the main histogram structure.
709///
710/// \param[in] name name of histogram (avoid blanks)
711/// \param[in] title histogram title.
712/// If title is of the form `stringt;stringx;stringy;stringz`
713/// the histogram title is set to `stringt`,
714/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
715/// \param[in] nbins number of bins
716/// \param[in] xbins array of low-edges for each bin.
717/// This is an array of type float and size nbins+1
718
719TH1::TH1(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
720 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
721{
722 Build();
723 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
724 if (xbins) fXaxis.Set(nbins,xbins);
725 else fXaxis.Set(nbins,0,1);
726 fNcells = fXaxis.GetNbins()+2;
727}
728
729////////////////////////////////////////////////////////////////////////////////
730/// Constructor for variable bin size histograms using an input array of type double.
731///
732/// \param[in] name name of histogram (avoid blanks)
733/// \param[in] title histogram title.
734/// If title is of the form `stringt;stringx;stringy;stringz`
735/// the histogram title is set to `stringt`,
736/// the x axis title to `stringx`, the y axis title to `stringy`, etc.
737/// \param[in] nbins number of bins
738/// \param[in] xbins array of low-edges for each bin.
739/// This is an array of type double and size nbins+1
740
741TH1::TH1(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
742 :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
743{
744 Build();
745 if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
746 if (xbins) fXaxis.Set(nbins,xbins);
747 else fXaxis.Set(nbins,0,1);
748 fNcells = fXaxis.GetNbins()+2;
749}
750
751////////////////////////////////////////////////////////////////////////////////
752/// Static function: cannot be inlined on Windows/NT.
753
755{
756 return fgAddDirectory;
757}
758
759////////////////////////////////////////////////////////////////////////////////
760/// Browse the Histogram object.
761
763{
764 Draw(b ? b->GetDrawOption() : "");
765 gPad->Update();
766}
767
768////////////////////////////////////////////////////////////////////////////////
769/// Creates histogram basic data structure.
770
772{
773 fDirectory = nullptr;
774 fPainter = nullptr;
775 fIntegral = nullptr;
776 fEntries = 0;
777 fNormFactor = 0;
779 fMaximum = -1111;
780 fMinimum = -1111;
781 fBufferSize = 0;
782 fBuffer = nullptr;
785 fXaxis.SetName("xaxis");
786 fYaxis.SetName("yaxis");
787 fZaxis.SetName("zaxis");
788 fYaxis.Set(1,0.,1.);
789 fZaxis.Set(1,0.,1.);
790 fXaxis.SetParent(this);
791 fYaxis.SetParent(this);
792 fZaxis.SetParent(this);
793
795
796 fFunctions = new TList;
797
799
802 if (fDirectory) {
804 fDirectory->Append(this,kTRUE);
805 }
806 }
807}
808
809////////////////////////////////////////////////////////////////////////////////
810/// Performs the operation: `this = this + c1*f1`
811/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
812///
813/// By default, the function is computed at the centre of the bin.
814/// if option "I" is specified (1-d histogram only), the integral of the
815/// function in each bin is used instead of the value of the function at
816/// the centre of the bin.
817///
818/// Only bins inside the function range are recomputed.
819///
820/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
821/// you should call Sumw2 before making this operation.
822/// This is particularly important if you fit the histogram after TH1::Add
823///
824/// The function return kFALSE if the Add operation failed
825
827{
828 if (!f1) {
829 Error("Add","Attempt to add a non-existing function");
830 return kFALSE;
831 }
832
833 TString opt = option;
834 opt.ToLower();
835 Bool_t integral = kFALSE;
836 if (opt.Contains("i") && fDimension == 1) integral = kTRUE;
837
838 Int_t ncellsx = GetNbinsX() + 2; // cells = normal bins + underflow bin + overflow bin
839 Int_t ncellsy = GetNbinsY() + 2;
840 Int_t ncellsz = GetNbinsZ() + 2;
841 if (fDimension < 2) ncellsy = 1;
842 if (fDimension < 3) ncellsz = 1;
843
844 // delete buffer if it is there since it will become invalid
845 if (fBuffer) BufferEmpty(1);
846
847 // - Add statistics
848 Double_t s1[10];
849 for (Int_t i = 0; i < 10; ++i) s1[i] = 0;
850 PutStats(s1);
851 SetMinimum();
852 SetMaximum();
853
854 // - Loop on bins (including underflows/overflows)
855 Int_t bin, binx, biny, binz;
856 Double_t cu=0;
857 Double_t xx[3];
858 Double_t *params = nullptr;
859 f1->InitArgs(xx,params);
860 for (binz = 0; binz < ncellsz; ++binz) {
861 xx[2] = fZaxis.GetBinCenter(binz);
862 for (biny = 0; biny < ncellsy; ++biny) {
863 xx[1] = fYaxis.GetBinCenter(biny);
864 for (binx = 0; binx < ncellsx; ++binx) {
865 xx[0] = fXaxis.GetBinCenter(binx);
866 if (!f1->IsInside(xx)) continue;
868 bin = binx + ncellsx * (biny + ncellsy * binz);
869 if (integral) {
870 cu = c1*f1->Integral(fXaxis.GetBinLowEdge(binx), fXaxis.GetBinUpEdge(binx), 0.) / fXaxis.GetBinWidth(binx);
871 } else {
872 cu = c1*f1->EvalPar(xx);
873 }
874 if (TF1::RejectedPoint()) continue;
875 AddBinContent(bin,cu);
876 }
877 }
878 }
879
880 return kTRUE;
881}
882
883int TH1::LoggedInconsistency(const char *name, const TH1 *h1, const TH1 *h2, bool useMerge) const
884{
885 const auto inconsistency = CheckConsistency(h1, h2);
886
887 if (inconsistency & kDifferentDimensions) {
888 if (useMerge)
889 Info(name, "Histograms have different dimensions - trying to use TH1::Merge");
890 else {
891 Error(name, "Histograms have different dimensions");
892 }
893 } else if (inconsistency & kDifferentNumberOfBins) {
894 if (useMerge)
895 Info(name, "Histograms have different number of bins - trying to use TH1::Merge");
896 else {
897 Error(name, "Histograms have different number of bins");
898 }
899 } else if (inconsistency & kDifferentAxisLimits) {
900 if (useMerge)
901 Info(name, "Histograms have different axis limits - trying to use TH1::Merge");
902 else
903 Warning(name, "Histograms have different axis limits");
904 } else if (inconsistency & kDifferentBinLimits) {
905 if (useMerge)
906 Info(name, "Histograms have different bin limits - trying to use TH1::Merge");
907 else
908 Warning(name, "Histograms have different bin limits");
909 } else if (inconsistency & kDifferentLabels) {
910 // in case of different labels -
911 if (useMerge)
912 Info(name, "Histograms have different labels - trying to use TH1::Merge");
913 else
914 Info(name, "Histograms have different labels");
915 }
916
917 return inconsistency;
918}
919
920////////////////////////////////////////////////////////////////////////////////
921/// Performs the operation: `this = this + c1*h1`
922/// If errors are defined (see TH1::Sumw2), errors are also recalculated.
923///
924/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
925/// if not already set.
926///
927/// Note also that adding histogram with labels is not supported, histogram will be
928/// added merging them by bin number independently of the labels.
929/// For adding histogram with labels one should use TH1::Merge
930///
931/// SPECIAL CASE (Average/Efficiency histograms)
932/// For histograms representing averages or efficiencies, one should compute the average
933/// of the two histograms and not the sum. One can mark a histogram to be an average
934/// histogram by setting its bit kIsAverage with
935/// myhist.SetBit(TH1::kIsAverage);
936/// Note that the two histograms must have their kIsAverage bit set
937///
938/// IMPORTANT NOTE1: If you intend to use the errors of this histogram later
939/// you should call Sumw2 before making this operation.
940/// This is particularly important if you fit the histogram after TH1::Add
941///
942/// IMPORTANT NOTE2: if h1 has a normalisation factor, the normalisation factor
943/// is used , ie this = this + c1*factor*h1
944/// Use the other TH1::Add function if you do not want this feature
945///
946/// IMPORTANT NOTE3: You should be careful about the statistics of the
947/// returned histogram, whose statistics may be binned or unbinned,
948/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
949/// and whether TH1::ResetStats has been called on either this or h1.
950/// See TH1::GetStats.
951///
952/// The function return kFALSE if the Add operation failed
953
955{
956 if (!h1) {
957 Error("Add","Attempt to add a non-existing histogram");
958 return kFALSE;
959 }
960
961 // delete buffer if it is there since it will become invalid
962 if (fBuffer) BufferEmpty(1);
963
964 bool useMerge = false;
965 const bool considerMerge = (c1 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
966 const auto inconsistency = LoggedInconsistency("Add", this, h1, considerMerge);
967 // If there is a bad inconsistency and we can't even consider merging, just give up
968 if(inconsistency >= kDifferentNumberOfBins && !considerMerge) {
969 return false;
970 }
971 // If there is an inconsistency, we try to use merging
972 if(inconsistency > kFullyConsistent) {
973 useMerge = considerMerge;
974 }
975
976 if (useMerge) {
977 TList l;
978 l.Add(const_cast<TH1*>(h1));
979 auto iret = Merge(&l);
980 return (iret >= 0);
981 }
982
983 // Create Sumw2 if h1 has Sumw2 set
984 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
985
986 // - Add statistics
987 Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() );
988
989 // statistics can be preserved only in case of positive coefficients
990 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
991 Bool_t resetStats = (c1 < 0);
992 Double_t s1[kNstat] = {0};
993 Double_t s2[kNstat] = {0};
994 if (!resetStats) {
995 // need to initialize to zero s1 and s2 since
996 // GetStats fills only used elements depending on dimension and type
997 GetStats(s1);
998 h1->GetStats(s2);
999 }
1000
1001 SetMinimum();
1002 SetMaximum();
1003
1004 // - Loop on bins (including underflows/overflows)
1005 Double_t factor = 1;
1006 if (h1->GetNormFactor() != 0) factor = h1->GetNormFactor()/h1->GetSumOfWeights();;
1007 Double_t c1sq = c1 * c1;
1008 Double_t factsq = factor * factor;
1009
1010 for (Int_t bin = 0; bin < fNcells; ++bin) {
1011 //special case where histograms have the kIsAverage bit set
1012 if (this->TestBit(kIsAverage) && h1->TestBit(kIsAverage)) {
1014 Double_t y2 = this->RetrieveBinContent(bin);
1015 Double_t e1sq = h1->GetBinErrorSqUnchecked(bin);
1016 Double_t e2sq = this->GetBinErrorSqUnchecked(bin);
1017 Double_t w1 = 1., w2 = 1.;
1018
1019 // consider all special cases when bin errors are zero
1020 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
1021 if (e1sq) w1 = 1. / e1sq;
1022 else if (h1->fSumw2.fN) {
1023 w1 = 1.E200; // use an arbitrary huge value
1024 if (y1 == 0) {
1025 // use an estimated error from the global histogram scale
1026 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
1027 w1 = 1./(sf*sf);
1028 }
1029 }
1030 if (e2sq) w2 = 1. / e2sq;
1031 else if (fSumw2.fN) {
1032 w2 = 1.E200; // use an arbitrary huge value
1033 if (y2 == 0) {
1034 // use an estimated error from the global histogram scale
1035 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
1036 w2 = 1./(sf*sf);
1037 }
1038 }
1039
1040 double y = (w1*y1 + w2*y2)/(w1 + w2);
1041 UpdateBinContent(bin, y);
1042 if (fSumw2.fN) {
1043 double err2 = 1./(w1 + w2);
1044 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1045 fSumw2.fArray[bin] = err2;
1046 }
1047 } else { // normal case of addition between histograms
1048 AddBinContent(bin, c1 * factor * h1->RetrieveBinContent(bin));
1049 if (fSumw2.fN) fSumw2.fArray[bin] += c1sq * factsq * h1->GetBinErrorSqUnchecked(bin);
1050 }
1051 }
1052
1053 // update statistics (do here to avoid changes by SetBinContent)
1054 if (resetStats) {
1055 // statistics need to be reset in case coefficient are negative
1056 ResetStats();
1057 }
1058 else {
1059 for (Int_t i=0;i<kNstat;i++) {
1060 if (i == 1) s1[i] += c1*c1*s2[i];
1061 else s1[i] += c1*s2[i];
1062 }
1063 PutStats(s1);
1064 SetEntries(entries);
1065 }
1066 return kTRUE;
1067}
1068
1069////////////////////////////////////////////////////////////////////////////////
1070/// Replace contents of this histogram by the addition of h1 and h2.
1071///
1072/// `this = c1*h1 + c2*h2`
1073/// if errors are defined (see TH1::Sumw2), errors are also recalculated
1074///
1075/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
1076/// if not already set.
1077///
1078/// Note also that adding histogram with labels is not supported, histogram will be
1079/// added merging them by bin number independently of the labels.
1080/// For adding histogram ith labels one should use TH1::Merge
1081///
1082/// SPECIAL CASE (Average/Efficiency histograms)
1083/// For histograms representing averages or efficiencies, one should compute the average
1084/// of the two histograms and not the sum. One can mark a histogram to be an average
1085/// histogram by setting its bit kIsAverage with
1086/// myhist.SetBit(TH1::kIsAverage);
1087/// Note that the two histograms must have their kIsAverage bit set
1088///
1089/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
1090/// you should call Sumw2 before making this operation.
1091/// This is particularly important if you fit the histogram after TH1::Add
1092///
1093/// IMPORTANT NOTE2: You should be careful about the statistics of the
1094/// returned histogram, whose statistics may be binned or unbinned,
1095/// depending on whether c1 is negative, whether TAxis::kAxisRange is true,
1096/// and whether TH1::ResetStats has been called on either this or h1.
1097/// See TH1::GetStats.
1098///
1099/// ANOTHER SPECIAL CASE : h1 = h2 and c2 < 0
1100/// do a scaling this = c1 * h1 / (bin Volume)
1101///
1102/// The function returns kFALSE if the Add operation failed
1103
1105{
1106
1107 if (!h1 || !h2) {
1108 Error("Add","Attempt to add a non-existing histogram");
1109 return kFALSE;
1110 }
1111
1112 // delete buffer if it is there since it will become invalid
1113 if (fBuffer) BufferEmpty(1);
1114
1115 Bool_t normWidth = kFALSE;
1116 if (h1 == h2 && c2 < 0) {c2 = 0; normWidth = kTRUE;}
1117
1118 if (h1 != h2) {
1119 bool useMerge = false;
1120 const bool considerMerge = (c1 == 1. && c2 == 1. && !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
1121
1122 // We can combine inconsistencies like this, since they are ordered and a
1123 // higher inconsistency is worse
1124 auto const inconsistency = std::max(LoggedInconsistency("Add", this, h1, considerMerge),
1125 LoggedInconsistency("Add", h1, h2, considerMerge));
1126
1127 // If there is a bad inconsistency and we can't even consider merging, just give up
1128 if(inconsistency >= kDifferentNumberOfBins && !considerMerge) {
1129 return false;
1130 }
1131 // If there is an inconsistency, we try to use merging
1132 if(inconsistency > kFullyConsistent) {
1133 useMerge = considerMerge;
1134 }
1135
1136 if (useMerge) {
1137 TList l;
1138 // why TList takes non-const pointers ????
1139 l.Add(const_cast<TH1*>(h1));
1140 l.Add(const_cast<TH1*>(h2));
1141 Reset("ICE");
1142 auto iret = Merge(&l);
1143 return (iret >= 0);
1144 }
1145 }
1146
1147 // Create Sumw2 if h1 or h2 have Sumw2 set
1148 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();
1149
1150 // - Add statistics
1151 Double_t nEntries = TMath::Abs( c1*h1->GetEntries() + c2*h2->GetEntries() );
1152
1153 // TODO remove
1154 // statistics can be preserved only in case of positive coefficients
1155 // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
1156 // also in case of scaling with the width we cannot preserve the statistics
1157 Double_t s1[kNstat] = {0};
1158 Double_t s2[kNstat] = {0};
1159 Double_t s3[kNstat];
1160
1161
1162 Bool_t resetStats = (c1*c2 < 0) || normWidth;
1163 if (!resetStats) {
1164 // need to initialize to zero s1 and s2 since
1165 // GetStats fills only used elements depending on dimension and type
1166 h1->GetStats(s1);
1167 h2->GetStats(s2);
1168 for (Int_t i=0;i<kNstat;i++) {
1169 if (i == 1) s3[i] = c1*c1*s1[i] + c2*c2*s2[i];
1170 //else s3[i] = TMath::Abs(c1)*s1[i] + TMath::Abs(c2)*s2[i];
1171 else s3[i] = c1*s1[i] + c2*s2[i];
1172 }
1173 }
1174
1175 SetMinimum();
1176 SetMaximum();
1177
1178 if (normWidth) { // DEPRECATED CASE: belongs to fitting / drawing modules
1179
1180 Int_t nbinsx = GetNbinsX() + 2; // normal bins + underflow, overflow
1181 Int_t nbinsy = GetNbinsY() + 2;
1182 Int_t nbinsz = GetNbinsZ() + 2;
1183
1184 if (fDimension < 2) nbinsy = 1;
1185 if (fDimension < 3) nbinsz = 1;
1186
1187 Int_t bin, binx, biny, binz;
1188 for (binz = 0; binz < nbinsz; ++binz) {
1189 Double_t wz = h1->GetZaxis()->GetBinWidth(binz);
1190 for (biny = 0; biny < nbinsy; ++biny) {
1191 Double_t wy = h1->GetYaxis()->GetBinWidth(biny);
1192 for (binx = 0; binx < nbinsx; ++binx) {
1193 Double_t wx = h1->GetXaxis()->GetBinWidth(binx);
1194 bin = GetBin(binx, biny, binz);
1195 Double_t w = wx*wy*wz;
1196 UpdateBinContent(bin, c1 * h1->RetrieveBinContent(bin) / w);
1197 if (fSumw2.fN) {
1198 Double_t e1 = h1->GetBinError(bin)/w;
1199 fSumw2.fArray[bin] = c1*c1*e1*e1;
1200 }
1201 }
1202 }
1203 }
1204 } else if (h1->TestBit(kIsAverage) && h2->TestBit(kIsAverage)) {
1205 for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
1206 // special case where histograms have the kIsAverage bit set
1208 Double_t y2 = h2->RetrieveBinContent(i);
1210 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
1211 Double_t w1 = 1., w2 = 1.;
1212
1213 // consider all special cases when bin errors are zero
1214 // see http://root-forum.cern.ch/viewtopic.php?f=3&t=13299
1215 if (e1sq) w1 = 1./ e1sq;
1216 else if (h1->fSumw2.fN) {
1217 w1 = 1.E200; // use an arbitrary huge value
1218 if (y1 == 0 ) { // use an estimated error from the global histogram scale
1219 double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
1220 w1 = 1./(sf*sf);
1221 }
1222 }
1223 if (e2sq) w2 = 1./ e2sq;
1224 else if (h2->fSumw2.fN) {
1225 w2 = 1.E200; // use an arbitrary huge value
1226 if (y2 == 0) { // use an estimated error from the global histogram scale
1227 double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
1228 w2 = 1./(sf*sf);
1229 }
1230 }
1231
1232 double y = (w1*y1 + w2*y2)/(w1 + w2);
1233 UpdateBinContent(i, y);
1234 if (fSumw2.fN) {
1235 double err2 = 1./(w1 + w2);
1236 if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0
1237 fSumw2.fArray[i] = err2;
1238 }
1239 }
1240 } else { // case of simple histogram addition
1241 Double_t c1sq = c1 * c1;
1242 Double_t c2sq = c2 * c2;
1243 for (Int_t i = 0; i < fNcells; ++i) { // Loop on cells (bins including underflows/overflows)
1244 UpdateBinContent(i, c1 * h1->RetrieveBinContent(i) + c2 * h2->RetrieveBinContent(i));
1245 if (fSumw2.fN) {
1246 fSumw2.fArray[i] = c1sq * h1->GetBinErrorSqUnchecked(i) + c2sq * h2->GetBinErrorSqUnchecked(i);
1247 }
1248 }
1249 }
1250
1251 if (resetStats) {
1252 // statistics need to be reset in case coefficient are negative
1253 ResetStats();
1254 }
1255 else {
1256 // update statistics (do here to avoid changes by SetBinContent) FIXME remove???
1257 PutStats(s3);
1258 SetEntries(nEntries);
1259 }
1260
1261 return kTRUE;
1262}
1263
1264////////////////////////////////////////////////////////////////////////////////
1265/// Increment bin content by 1.
1266/// Passing an out-of-range bin leads to undefined behavior
1267
1269{
1270 AbstractMethod("AddBinContent");
1271}
1272
1273////////////////////////////////////////////////////////////////////////////////
1274/// Increment bin content by a weight w.
1275/// Passing an out-of-range bin leads to undefined behavior
1276
1278{
1279 AbstractMethod("AddBinContent");
1280}
1281
1282////////////////////////////////////////////////////////////////////////////////
1283/// Sets the flag controlling the automatic add of histograms in memory
1284///
1285/// By default (fAddDirectory = kTRUE), histograms are automatically added
1286/// to the list of objects in memory.
1287/// Note that one histogram can be removed from its support directory
1288/// by calling h->SetDirectory(nullptr) or h->SetDirectory(dir) to add it
1289/// to the list of objects in the directory dir.
1290///
1291/// NOTE that this is a static function. To call it, use;
1292/// TH1::AddDirectory
1293
1295{
1296 fgAddDirectory = add;
1297}
1298
1299////////////////////////////////////////////////////////////////////////////////
1300/// Auxiliary function to get the power of 2 next (larger) or previous (smaller)
1301/// a given x
1302///
1303/// next = kTRUE : next larger
1304/// next = kFALSE : previous smaller
1305///
1306/// Used by the autobin power of 2 algorithm
1307
1309{
1310 Int_t nn;
1311 Double_t f2 = std::frexp(x, &nn);
1312 return ((next && x > 0.) || (!next && x <= 0.)) ? std::ldexp(std::copysign(1., f2), nn)
1313 : std::ldexp(std::copysign(1., f2), --nn);
1314}
1315
1316////////////////////////////////////////////////////////////////////////////////
1317/// Auxiliary function to get the next power of 2 integer value larger then n
1318///
1319/// Used by the autobin power of 2 algorithm
1320
1322{
1323 Int_t nn;
1324 Double_t f2 = std::frexp(n, &nn);
1325 if (TMath::Abs(f2 - .5) > 0.001)
1326 return (Int_t)std::ldexp(1., nn);
1327 return n;
1328}
1329
1330////////////////////////////////////////////////////////////////////////////////
1331/// Buffer-based estimate of the histogram range using the power of 2 algorithm.
1332///
1333/// Used by the autobin power of 2 algorithm.
1334///
1335/// Works on arguments (min and max from fBuffer) and internal inputs: fXmin,
1336/// fXmax, NBinsX (from fXaxis), ...
1337/// Result save internally in fXaxis.
1338///
1339/// Overloaded by TH2 and TH3.
1340///
1341/// Return -1 if internal inputs are inconsistent, 0 otherwise.
1342
1344{
1345 // We need meaningful raw limits
1346 if (xmi >= xma)
1347 return -1;
1348
1350 Double_t xhmi = fXaxis.GetXmin();
1351 Double_t xhma = fXaxis.GetXmax();
1352
1353 // Now adjust
1354 if (TMath::Abs(xhma) > TMath::Abs(xhmi)) {
1355 // Start from the upper limit
1356 xhma = TH1::AutoP2GetPower2(xhma);
1357 xhmi = xhma - TH1::AutoP2GetPower2(xhma - xhmi);
1358 } else {
1359 // Start from the lower limit
1360 xhmi = TH1::AutoP2GetPower2(xhmi, kFALSE);
1361 xhma = xhmi + TH1::AutoP2GetPower2(xhma - xhmi);
1362 }
1363
1364 // Round the bins to the next power of 2; take into account the possible inflation
1365 // of the range
1366 Double_t rr = (xhma - xhmi) / (xma - xmi);
1367 Int_t nb = TH1::AutoP2GetBins((Int_t)(rr * GetNbinsX()));
1368
1369 // Adjust using the same bin width and offsets
1370 Double_t bw = (xhma - xhmi) / nb;
1371 // Bins to left free on each side
1372 Double_t autoside = gEnv->GetValue("Hist.Binning.Auto.Side", 0.05);
1373 Int_t nbside = (Int_t)(nb * autoside);
1374
1375 // Side up
1376 Int_t nbup = (xhma - xma) / bw;
1377 if (nbup % 2 != 0)
1378 nbup++; // Must be even
1379 if (nbup != nbside) {
1380 // Accounts also for both case: larger or smaller
1381 xhma -= bw * (nbup - nbside);
1382 nb -= (nbup - nbside);
1383 }
1384
1385 // Side low
1386 Int_t nblw = (xmi - xhmi) / bw;
1387 if (nblw % 2 != 0)
1388 nblw++; // Must be even
1389 if (nblw != nbside) {
1390 // Accounts also for both case: larger or smaller
1391 xhmi += bw * (nblw - nbside);
1392 nb -= (nblw - nbside);
1393 }
1394
1395 // Set everything and project
1396 SetBins(nb, xhmi, xhma);
1397
1398 // Done
1399 return 0;
1400}
1401
1402/// Fill histogram with all entries in the buffer.
1403///
1404/// - action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
1405/// - action = 0 histogram is reset and filled from the buffer. When the histogram is filled from the
1406/// buffer the value fBuffer[0] is set to a negative number (= - number of entries)
1407/// When calling with action == 0 the histogram is NOT refilled when fBuffer[0] is < 0
1408/// While when calling with action = -1 the histogram is reset and ALWAYS refilled independently if
1409/// the histogram was filled before. This is needed when drawing the histogram
1410/// - action = 1 histogram is filled and buffer is deleted
1411/// The buffer is automatically deleted when filling the histogram and the entries is
1412/// larger than the buffer size
1413
1415{
1416 // do we need to compute the bin size?
1417 if (!fBuffer) return 0;
1418 Int_t nbentries = (Int_t)fBuffer[0];
1419
1420 // nbentries correspond to the number of entries of histogram
1421
1422 if (nbentries == 0) {
1423 // if action is 1 we delete the buffer
1424 // this will avoid infinite recursion
1425 if (action > 0) {
1426 delete [] fBuffer;
1427 fBuffer = nullptr;
1428 fBufferSize = 0;
1429 }
1430 return 0;
1431 }
1432 if (nbentries < 0 && action == 0) return 0; // case histogram has been already filled from the buffer
1433
1434 Double_t *buffer = fBuffer;
1435 if (nbentries < 0) {
1436 nbentries = -nbentries;
1437 // a reset might call BufferEmpty() giving an infinite recursion
1438 // Protect it by setting fBuffer = nullptr
1439 fBuffer = nullptr;
1440 //do not reset the list of functions
1441 Reset("ICES");
1442 fBuffer = buffer;
1443 }
1444 if (CanExtendAllAxes() || (fXaxis.GetXmax() <= fXaxis.GetXmin())) {
1445 //find min, max of entries in buffer
1448 for (Int_t i=0;i<nbentries;i++) {
1449 Double_t x = fBuffer[2*i+2];
1450 // skip infinity or NaN values
1451 if (!std::isfinite(x)) continue;
1452 if (x < xmin) xmin = x;
1453 if (x > xmax) xmax = x;
1454 }
1455 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
1456 Int_t rc = -1;
1458 if ((rc = AutoP2FindLimits(xmin, xmax)) < 0)
1459 Warning("BufferEmpty",
1460 "inconsistency found by power-of-2 autobin algorithm: fallback to standard method");
1461 }
1462 if (rc < 0)
1464 } else {
1465 fBuffer = nullptr;
1466 Int_t keep = fBufferSize; fBufferSize = 0;
1468 if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax, &fXaxis);
1469 fBuffer = buffer;
1470 fBufferSize = keep;
1471 }
1472 }
1473
1474 // call DoFillN which will not put entries in the buffer as FillN does
1475 // set fBuffer to zero to avoid re-emptying the buffer from functions called
1476 // by DoFillN (e.g Sumw2)
1477 buffer = fBuffer; fBuffer = nullptr;
1478 DoFillN(nbentries,&buffer[2],&buffer[1],2);
1479 fBuffer = buffer;
1480
1481 // if action == 1 - delete the buffer
1482 if (action > 0) {
1483 delete [] fBuffer;
1484 fBuffer = nullptr;
1485 fBufferSize = 0;
1486 } else {
1487 // if number of entries is consistent with buffer - set it negative to avoid
1488 // refilling the histogram every time BufferEmpty(0) is called
1489 // In case it is not consistent, by setting fBuffer[0]=0 is like resetting the buffer
1490 // (it will not be used anymore the next time BufferEmpty is called)
1491 if (nbentries == (Int_t)fEntries)
1492 fBuffer[0] = -nbentries;
1493 else
1494 fBuffer[0] = 0;
1495 }
1496 return nbentries;
1497}
1498
1499////////////////////////////////////////////////////////////////////////////////
1500/// accumulate arguments in buffer. When buffer is full, empty the buffer
1501///
1502/// - `fBuffer[0]` = number of entries in buffer
1503/// - `fBuffer[1]` = w of first entry
1504/// - `fBuffer[2]` = x of first entry
1505
1507{
1508 if (!fBuffer) return -2;
1509 Int_t nbentries = (Int_t)fBuffer[0];
1510
1511
1512 if (nbentries < 0) {
1513 // reset nbentries to a positive value so next time BufferEmpty() is called
1514 // the histogram will be refilled
1515 nbentries = -nbentries;
1516 fBuffer[0] = nbentries;
1517 if (fEntries > 0) {
1518 // set fBuffer to zero to avoid calling BufferEmpty in Reset
1519 Double_t *buffer = fBuffer; fBuffer=nullptr;
1520 Reset("ICES"); // do not reset list of functions
1521 fBuffer = buffer;
1522 }
1523 }
1524 if (2*nbentries+2 >= fBufferSize) {
1525 BufferEmpty(1);
1526 if (!fBuffer)
1527 // to avoid infinite recursion Fill->BufferFill->Fill
1528 return Fill(x,w);
1529 // this cannot happen
1530 R__ASSERT(0);
1531 }
1532 fBuffer[2*nbentries+1] = w;
1533 fBuffer[2*nbentries+2] = x;
1534 fBuffer[0] += 1;
1535 return -2;
1536}
1537
1538////////////////////////////////////////////////////////////////////////////////
1539/// Check bin limits.
1540
1541bool TH1::CheckBinLimits(const TAxis* a1, const TAxis * a2)
1542{
1543 const TArrayD * h1Array = a1->GetXbins();
1544 const TArrayD * h2Array = a2->GetXbins();
1545 Int_t fN = h1Array->fN;
1546 if ( fN != 0 ) {
1547 if ( h2Array->fN != fN ) {
1548 return false;
1549 }
1550 else {
1551 for ( int i = 0; i < fN; ++i ) {
1552 // for i==fN (nbin+1) a->GetBinWidth() returns last bin width
1553 // we do not need to exclude that case
1554 double binWidth = a1->GetBinWidth(i);
1555 if ( ! TMath::AreEqualAbs( h1Array->GetAt(i), h2Array->GetAt(i), binWidth*1E-10 ) ) {
1556 return false;
1557 }
1558 }
1559 }
1560 }
1561
1562 return true;
1563}
1564
1565////////////////////////////////////////////////////////////////////////////////
1566/// Check that axis have same labels.
1567
1568bool TH1::CheckBinLabels(const TAxis* a1, const TAxis * a2)
1569{
1570 THashList *l1 = a1->GetLabels();
1571 THashList *l2 = a2->GetLabels();
1572
1573 if (!l1 && !l2 )
1574 return true;
1575 if (!l1 || !l2 ) {
1576 return false;
1577 }
1578 // check now labels sizes are the same
1579 if (l1->GetSize() != l2->GetSize() ) {
1580 return false;
1581 }
1582 for (int i = 1; i <= a1->GetNbins(); ++i) {
1583 TString label1 = a1->GetBinLabel(i);
1584 TString label2 = a2->GetBinLabel(i);
1585 if (label1 != label2) {
1586 return false;
1587 }
1588 }
1589
1590 return true;
1591}
1592
1593////////////////////////////////////////////////////////////////////////////////
1594/// Check that the axis limits of the histograms are the same.
1595/// If a first and last bin is passed the axis is compared between the given range
1596
1597bool TH1::CheckAxisLimits(const TAxis *a1, const TAxis *a2 )
1598{
1599 double firstBin = a1->GetBinWidth(1);
1600 double lastBin = a1->GetBinWidth( a1->GetNbins() );
1601 if ( ! TMath::AreEqualAbs(a1->GetXmin(), a2->GetXmin(), firstBin* 1.E-10) ||
1602 ! TMath::AreEqualAbs(a1->GetXmax(), a2->GetXmax(), lastBin*1.E-10) ) {
1603 return false;
1604 }
1605 return true;
1606}
1607
1608////////////////////////////////////////////////////////////////////////////////
1609/// Check that the axis are the same
1610
1611bool TH1::CheckEqualAxes(const TAxis *a1, const TAxis *a2 )
1612{
1613 if (a1->GetNbins() != a2->GetNbins() ) {
1614 ::Info("CheckEqualAxes","Axes have different number of bins : nbin1 = %d nbin2 = %d",a1->GetNbins(),a2->GetNbins() );
1615 return false;
1616 }
1617 if(!CheckAxisLimits(a1,a2)) {
1618 ::Info("CheckEqualAxes","Axes have different limits");
1619 return false;
1620 }
1621 if(!CheckBinLimits(a1,a2)) {
1622 ::Info("CheckEqualAxes","Axes have different bin limits");
1623 return false;
1624 }
1625
1626 // check labels
1627 if(!CheckBinLabels(a1,a2)) {
1628 ::Info("CheckEqualAxes","Axes have different labels");
1629 return false;
1630 }
1631
1632 return true;
1633}
1634
1635////////////////////////////////////////////////////////////////////////////////
1636/// Check that two sub axis are the same.
1637/// The limits are defined by first bin and last bin
1638/// N.B. no check is done in this case for variable bins
1639
1640bool TH1::CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis * a2, Int_t firstBin2, Int_t lastBin2 )
1641{
1642 // By default is assumed that no bins are given for the second axis
1643 Int_t nbins1 = lastBin1-firstBin1 + 1;
1644 Double_t xmin1 = a1->GetBinLowEdge(firstBin1);
1645 Double_t xmax1 = a1->GetBinUpEdge(lastBin1);
1646
1647 Int_t nbins2 = a2->GetNbins();
1648 Double_t xmin2 = a2->GetXmin();
1649 Double_t xmax2 = a2->GetXmax();
1650
1651 if (firstBin2 < lastBin2) {
1652 // in this case assume no bins are given for the second axis
1653 nbins2 = lastBin1-firstBin1 + 1;
1654 xmin2 = a1->GetBinLowEdge(firstBin1);
1655 xmax2 = a1->GetBinUpEdge(lastBin1);
1656 }
1657
1658 if (nbins1 != nbins2 ) {
1659 ::Info("CheckConsistentSubAxes","Axes have different number of bins");
1660 return false;
1661 }
1662
1663 Double_t firstBin = a1->GetBinWidth(firstBin1);
1664 Double_t lastBin = a1->GetBinWidth(lastBin1);
1665 if ( ! TMath::AreEqualAbs(xmin1,xmin2,1.E-10 * firstBin) ||
1666 ! TMath::AreEqualAbs(xmax1,xmax2,1.E-10 * lastBin) ) {
1667 ::Info("CheckConsistentSubAxes","Axes have different limits");
1668 return false;
1669 }
1670
1671 return true;
1672}
1673
1674////////////////////////////////////////////////////////////////////////////////
1675/// Check histogram compatibility.
1676
1677int TH1::CheckConsistency(const TH1* h1, const TH1* h2)
1678{
1679 if (h1 == h2) return kFullyConsistent;
1680
1681 if (h1->GetDimension() != h2->GetDimension() ) {
1682 return kDifferentDimensions;
1683 }
1684 Int_t dim = h1->GetDimension();
1685
1686 // returns kTRUE if number of bins and bin limits are identical
1687 Int_t nbinsx = h1->GetNbinsX();
1688 Int_t nbinsy = h1->GetNbinsY();
1689 Int_t nbinsz = h1->GetNbinsZ();
1690
1691 // Check whether the histograms have the same number of bins.
1692 if (nbinsx != h2->GetNbinsX() ||
1693 (dim > 1 && nbinsy != h2->GetNbinsY()) ||
1694 (dim > 2 && nbinsz != h2->GetNbinsZ()) ) {
1695 return kDifferentNumberOfBins;
1696 }
1697
1698 bool ret = true;
1699
1700 // check axis limits
1701 ret &= CheckAxisLimits(h1->GetXaxis(), h2->GetXaxis());
1702 if (dim > 1) ret &= CheckAxisLimits(h1->GetYaxis(), h2->GetYaxis());
1703 if (dim > 2) ret &= CheckAxisLimits(h1->GetZaxis(), h2->GetZaxis());
1704 if (!ret) return kDifferentAxisLimits;
1705
1706 // check bin limits
1707 ret &= CheckBinLimits(h1->GetXaxis(), h2->GetXaxis());
1708 if (dim > 1) ret &= CheckBinLimits(h1->GetYaxis(), h2->GetYaxis());
1709 if (dim > 2) ret &= CheckBinLimits(h1->GetZaxis(), h2->GetZaxis());
1710 if (!ret) return kDifferentBinLimits;
1711
1712 // check labels if histograms are both not empty
1713 if ( !h1->IsEmpty() && !h2->IsEmpty() ) {
1714 ret &= CheckBinLabels(h1->GetXaxis(), h2->GetXaxis());
1715 if (dim > 1) ret &= CheckBinLabels(h1->GetYaxis(), h2->GetYaxis());
1716 if (dim > 2) ret &= CheckBinLabels(h1->GetZaxis(), h2->GetZaxis());
1717 if (!ret) return kDifferentLabels;
1718 }
1719
1720 return kFullyConsistent;
1721}
1722
1723////////////////////////////////////////////////////////////////////////////////
1724/// \f$ \chi^{2} \f$ test for comparing weighted and unweighted histograms.
1725///
1726/// Compares the histograms' adjusted (normalized) residuals.
1727/// Function: Returns p-value. Other return values are specified by the 3rd parameter
1728///
1729/// \param[in] h2 the second histogram
1730/// \param[in] option
1731/// - "UU" = experiment experiment comparison (unweighted-unweighted)
1732/// - "UW" = experiment MC comparison (unweighted-weighted). Note that
1733/// the first histogram should be unweighted
1734/// - "WW" = MC MC comparison (weighted-weighted)
1735/// - "NORM" = to be used when one or both of the histograms is scaled
1736/// but the histogram originally was unweighted
1737/// - by default underflows and overflows are not included:
1738/// * "OF" = overflows included
1739/// * "UF" = underflows included
1740/// - "P" = print chi2, ndf, p_value, igood
1741/// - "CHI2" = returns chi2 instead of p-value
1742/// - "CHI2/NDF" = returns \f$ \chi^{2} \f$/ndf
1743/// \param[in] res not empty - computes normalized residuals and returns them in this array
1744///
1745/// The current implementation is based on the papers \f$ \chi^{2} \f$ test for comparison
1746/// of weighted and unweighted histograms" in Proceedings of PHYSTAT05 and
1747/// "Comparison weighted and unweighted histograms", arXiv:physics/0605123
1748/// by N.Gagunashvili. This function has been implemented by Daniel Haertl in August 2006.
1749///
1750/// #### Introduction:
1751///
1752/// A frequently used technique in data analysis is the comparison of
1753/// histograms. First suggested by Pearson [1] the \f$ \chi^{2} \f$ test of
1754/// homogeneity is used widely for comparing usual (unweighted) histograms.
1755/// This paper describes the implementation modified \f$ \chi^{2} \f$ tests
1756/// for comparison of weighted and unweighted histograms and two weighted
1757/// histograms [2] as well as usual Pearson's \f$ \chi^{2} \f$ test for
1758/// comparison two usual (unweighted) histograms.
1759///
1760/// #### Overview:
1761///
1762/// Comparison of two histograms expect hypotheses that two histograms
1763/// represent identical distributions. To make a decision p-value should
1764/// be calculated. The hypotheses of identity is rejected if the p-value is
1765/// lower then some significance level. Traditionally significance levels
1766/// 0.1, 0.05 and 0.01 are used. The comparison procedure should include an
1767/// analysis of the residuals which is often helpful in identifying the
1768/// bins of histograms responsible for a significant overall \f$ \chi^{2} \f$ value.
1769/// Residuals are the difference between bin contents and expected bin
1770/// contents. Most convenient for analysis are the normalized residuals. If
1771/// hypotheses of identity are valid then normalized residuals are
1772/// approximately independent and identically distributed random variables
1773/// having N(0,1) distribution. Analysis of residuals expect test of above
1774/// mentioned properties of residuals. Notice that indirectly the analysis
1775/// of residuals increase the power of \f$ \chi^{2} \f$ test.
1776///
1777/// #### Methods of comparison:
1778///
1779/// \f$ \chi^{2} \f$ test for comparison two (unweighted) histograms:
1780/// Let us consider two histograms with the same binning and the number
1781/// of bins equal to r. Let us denote the number of events in the ith bin
1782/// in the first histogram as ni and as mi in the second one. The total
1783/// number of events in the first histogram is equal to:
1784/// \f[
1785/// N = \sum_{i=1}^{r} n_{i}
1786/// \f]
1787/// and
1788/// \f[
1789/// M = \sum_{i=1}^{r} m_{i}
1790/// \f]
1791/// in the second histogram. The hypothesis of identity (homogeneity) [3]
1792/// is that the two histograms represent random values with identical
1793/// distributions. It is equivalent that there exist r constants p1,...,pr,
1794/// such that
1795/// \f[
1796///\sum_{i=1}^{r} p_{i}=1
1797/// \f]
1798/// and the probability of belonging to the ith bin for some measured value
1799/// in both experiments is equal to pi. The number of events in the ith
1800/// bin is a random variable with a distribution approximated by a Poisson
1801/// probability distribution
1802/// \f[
1803///\frac{e^{-Np_{i}}(Np_{i})^{n_{i}}}{n_{i}!}
1804/// \f]
1805///for the first histogram and with distribution
1806/// \f[
1807///\frac{e^{-Mp_{i}}(Mp_{i})^{m_{i}}}{m_{i}!}
1808/// \f]
1809/// for the second histogram. If the hypothesis of homogeneity is valid,
1810/// then the maximum likelihood estimator of pi, i=1,...,r, is
1811/// \f[
1812///\hat{p}_{i}= \frac{n_{i}+m_{i}}{N+M}
1813/// \f]
1814/// and then
1815/// \f[
1816/// 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}}
1817/// \f]
1818/// has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [3].
1819/// The comparison procedure can include an analysis of the residuals which
1820/// is often helpful in identifying the bins of histograms responsible for
1821/// a significant overall \f$ \chi^{2} \f$ value. Most convenient for
1822/// analysis are the adjusted (normalized) residuals [4]
1823/// \f[
1824/// 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))}}
1825/// \f]
1826/// If hypotheses of homogeneity are valid then residuals ri are
1827/// approximately independent and identically distributed random variables
1828/// having N(0,1) distribution. The application of the \f$ \chi^{2} \f$ test has
1829/// restrictions related to the value of the expected frequencies Npi,
1830/// Mpi, i=1,...,r. A conservative rule formulated in [5] is that all the
1831/// expectations must be 1 or greater for both histograms. In practical
1832/// cases when expected frequencies are not known the estimated expected
1833/// frequencies \f$ M\hat{p}_{i}, N\hat{p}_{i}, i=1,...,r \f$ can be used.
1834///
1835/// #### Unweighted and weighted histograms comparison:
1836///
1837/// A simple modification of the ideas described above can be used for the
1838/// comparison of the usual (unweighted) and weighted histograms. Let us
1839/// denote the number of events in the ith bin in the unweighted
1840/// histogram as ni and the common weight of events in the ith bin of the
1841/// weighted histogram as wi. The total number of events in the
1842/// unweighted histogram is equal to
1843///\f[
1844/// N = \sum_{i=1}^{r} n_{i}
1845///\f]
1846/// and the total weight of events in the weighted histogram is equal to
1847///\f[
1848/// W = \sum_{i=1}^{r} w_{i}
1849///\f]
1850/// Let us formulate the hypothesis of identity of an unweighted histogram
1851/// to a weighted histogram so that there exist r constants p1,...,pr, such
1852/// that
1853///\f[
1854/// \sum_{i=1}^{r} p_{i} = 1
1855///\f]
1856/// for the unweighted histogram. The weight wi is a random variable with a
1857/// distribution approximated by the normal probability distribution
1858/// \f$ N(Wp_{i},\sigma_{i}^{2}) \f$ where \f$ \sigma_{i}^{2} \f$ is the variance of the weight wi.
1859/// If we replace the variance \f$ \sigma_{i}^{2} \f$
1860/// with estimate \f$ s_{i}^{2} \f$ (sum of squares of weights of
1861/// events in the ith bin) and the hypothesis of identity is valid, then the
1862/// maximum likelihood estimator of pi,i=1,...,r, is
1863///\f[
1864/// \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}}
1865///\f]
1866/// We may then use the test statistic
1867///\f[
1868/// 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}}
1869///\f]
1870/// and it has approximately a \f$ \sigma^{2}_{(r-1)} \f$ distribution [2]. This test, as well
1871/// as the original one [3], has a restriction on the expected frequencies. The
1872/// expected frequencies recommended for the weighted histogram is more than 25.
1873/// The value of the minimal expected frequency can be decreased down to 10 for
1874/// the case when the weights of the events are close to constant. In the case
1875/// of a weighted histogram if the number of events is unknown, then we can
1876/// apply this recommendation for the equivalent number of events as
1877///\f[
1878/// n_{i}^{equiv} = \frac{ w_{i}^{2} }{ s_{i}^{2} }
1879///\f]
1880/// The minimal expected frequency for an unweighted histogram must be 1. Notice
1881/// that any usual (unweighted) histogram can be considered as a weighted
1882/// histogram with events that have constant weights equal to 1.
1883/// The variance \f$ z_{i}^{2} \f$ of the difference between the weight wi
1884/// and the estimated expectation value of the weight is approximately equal to:
1885///\f[
1886/// 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}
1887///\f]
1888/// The residuals
1889///\f[
1890/// r_{i} = \frac{w_{i}-W\hat{p}_{i}}{z_{i}}
1891///\f]
1892/// have approximately a normal distribution with mean equal to 0 and standard
1893/// deviation equal to 1.
1894///
1895/// #### Two weighted histograms comparison:
1896///
1897/// Let us denote the common weight of events of the ith bin in the first
1898/// histogram as w1i and as w2i in the second one. The total weight of events
1899/// in the first histogram is equal to
1900///\f[
1901/// W_{1} = \sum_{i=1}^{r} w_{1i}
1902///\f]
1903/// and
1904///\f[
1905/// W_{2} = \sum_{i=1}^{r} w_{2i}
1906///\f]
1907/// in the second histogram. Let us formulate the hypothesis of identity of
1908/// weighted histograms so that there exist r constants p1,...,pr, such that
1909///\f[
1910/// \sum_{i=1}^{r} p_{i} = 1
1911///\f]
1912/// and also expectation value of weight w1i equal to W1pi and expectation value
1913/// of weight w2i equal to W2pi. Weights in both the histograms are random
1914/// variables with distributions which can be approximated by a normal
1915/// probability distribution \f$ N(W_{1}p_{i},\sigma_{1i}^{2}) \f$ for the first histogram
1916/// and by a distribution \f$ N(W_{2}p_{i},\sigma_{2i}^{2}) \f$ for the second.
1917/// Here \f$ \sigma_{1i}^{2} \f$ and \f$ \sigma_{2i}^{2} \f$ are the variances
1918/// of w1i and w2i with estimators \f$ s_{1i}^{2} \f$ and \f$ s_{2i}^{2} \f$ respectively.
1919/// If the hypothesis of identity is valid, then the maximum likelihood and
1920/// Least Square Method estimator of pi,i=1,...,r, is
1921///\f[
1922/// \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}}
1923///\f]
1924/// We may then use the test statistic
1925///\f[
1926/// 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}}
1927///\f]
1928/// and it has approximately a \f$ \chi^{2}_{(r-1)} \f$ distribution [2].
1929/// The normalized or studentised residuals [6]
1930///\f[
1931/// 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})}}}
1932///\f]
1933/// have approximately a normal distribution with mean equal to 0 and standard
1934/// deviation 1. A recommended minimal expected frequency is equal to 10 for
1935/// the proposed test.
1936///
1937/// #### Numerical examples:
1938///
1939/// The method described herein is now illustrated with an example.
1940/// We take a distribution
1941///\f[
1942/// \phi(x) = \frac{2}{(x-10)^{2}+1} + \frac{1}{(x-14)^{2}+1} (1)
1943///\f]
1944/// defined on the interval [4,16]. Events distributed according to the formula
1945/// (1) are simulated to create the unweighted histogram. Uniformly distributed
1946/// events are simulated for the weighted histogram with weights calculated by
1947/// formula (1). Each histogram has the same number of bins: 20. Fig.1 shows
1948/// the result of comparison of the unweighted histogram with 200 events
1949/// (minimal expected frequency equal to one) and the weighted histogram with
1950/// 500 events (minimal expected frequency equal to 25)
1951/// Begin_Macro
1952/// ../../../tutorials/math/chi2test.C
1953/// End_Macro
1954/// Fig 1. An example of comparison of the unweighted histogram with 200 events
1955/// and the weighted histogram with 500 events:
1956/// 1. unweighted histogram;
1957/// 2. weighted histogram;
1958/// 3. normalized residuals plot;
1959/// 4. normal Q-Q plot of residuals.
1960///
1961/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1962/// 21.09 with p-value equal to 0.33, therefore the hypothesis of identity of
1963/// the two histograms can be accepted for 0.05 significant level. The behavior
1964/// of the normalized residuals plot (see Fig. 1c) and the normal Q-Q plot
1965/// (see Fig. 1d) of residuals are regular and we cannot identify the outliers
1966/// or bins with a big influence on \f$ \chi^{2} \f$.
1967///
1968/// The second example presents the same two histograms but 17 events was added
1969/// to content of bin number 15 in unweighted histogram. Fig.2 shows the result
1970/// of comparison of the unweighted histogram with 217 events (minimal expected
1971/// frequency equal to one) and the weighted histogram with 500 events (minimal
1972/// expected frequency equal to 25)
1973/// Begin_Macro
1974/// ../../../tutorials/math/chi2test.C(17)
1975/// End_Macro
1976/// Fig 2. An example of comparison of the unweighted histogram with 217 events
1977/// and the weighted histogram with 500 events:
1978/// 1. unweighted histogram;
1979/// 2. weighted histogram;
1980/// 3. normalized residuals plot;
1981/// 4. normal Q-Q plot of residuals.
1982///
1983/// The value of the test statistic \f$ \chi^{2} \f$ is equal to
1984/// 32.33 with p-value equal to 0.029, therefore the hypothesis of identity of
1985/// the two histograms is rejected for 0.05 significant level. The behavior of
1986/// the normalized residuals plot (see Fig. 2c) and the normal Q-Q plot (see
1987/// Fig. 2d) of residuals are not regular and we can identify the outlier or
1988/// bin with a big influence on \f$ \chi^{2} \f$.
1989///
1990/// #### References:
1991///
1992/// - [1] Pearson, K., 1904. On the Theory of Contingency and Its Relation to
1993/// Association and Normal Correlation. Drapers' Co. Memoirs, Biometric
1994/// Series No. 1, London.
1995/// - [2] Gagunashvili, N., 2006. \f$ \sigma^{2} \f$ test for comparison
1996/// of weighted and unweighted histograms. Statistical Problems in Particle
1997/// Physics, Astrophysics and Cosmology, Proceedings of PHYSTAT05,
1998/// Oxford, UK, 12-15 September 2005, Imperial College Press, London, 43-44.
1999/// Gagunashvili,N., Comparison of weighted and unweighted histograms,
2000/// arXiv:physics/0605123, 2006.
2001/// - [3] Cramer, H., 1946. Mathematical methods of statistics.
2002/// Princeton University Press, Princeton.
2003/// - [4] Haberman, S.J., 1973. The analysis of residuals in cross-classified tables.
2004/// Biometrics 29, 205-220.
2005/// - [5] Lewontin, R.C. and Felsenstein, J., 1965. The robustness of homogeneity
2006/// test in 2xN tables. Biometrics 21, 19-33.
2007/// - [6] Seber, G.A.F., Lee, A.J., 2003, Linear Regression Analysis.
2008/// John Wiley & Sons Inc., New York.
2009
2010Double_t TH1::Chi2Test(const TH1* h2, Option_t *option, Double_t *res) const
2011{
2012 Double_t chi2 = 0;
2013 Int_t ndf = 0, igood = 0;
2014
2015 TString opt = option;
2016 opt.ToUpper();
2017
2018 Double_t prob = Chi2TestX(h2,chi2,ndf,igood,option,res);
2019
2020 if(opt.Contains("P")) {
2021 printf("Chi2 = %f, Prob = %g, NDF = %d, igood = %d\n", chi2,prob,ndf,igood);
2022 }
2023 if(opt.Contains("CHI2/NDF")) {
2024 if (ndf == 0) return 0;
2025 return chi2/ndf;
2026 }
2027 if(opt.Contains("CHI2")) {
2028 return chi2;
2029 }
2030
2031 return prob;
2032}
2033
2034////////////////////////////////////////////////////////////////////////////////
2035/// The computation routine of the Chisquare test. For the method description,
2036/// see Chi2Test() function.
2037///
2038/// \return p-value
2039/// \param[in] h2 the second histogram
2040/// \param[in] option
2041/// - "UU" = experiment experiment comparison (unweighted-unweighted)
2042/// - "UW" = experiment MC comparison (unweighted-weighted). Note that the first
2043/// histogram should be unweighted
2044/// - "WW" = MC MC comparison (weighted-weighted)
2045/// - "NORM" = if one or both histograms is scaled
2046/// - "OF" = overflows included
2047/// - "UF" = underflows included
2048/// by default underflows and overflows are not included
2049/// \param[out] igood test output
2050/// - igood=0 - no problems
2051/// - For unweighted unweighted comparison
2052/// - igood=1'There is a bin in the 1st histogram with less than 1 event'
2053/// - igood=2'There is a bin in the 2nd histogram with less than 1 event'
2054/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2055/// - For unweighted weighted comparison
2056/// - igood=1'There is a bin in the 1st histogram with less then 1 event'
2057/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective number of events'
2058/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2059/// - For weighted weighted comparison
2060/// - igood=1'There is a bin in the 1st histogram with less then 10 effective
2061/// number of events'
2062/// - igood=2'There is a bin in the 2nd histogram with less then 10 effective
2063/// number of events'
2064/// - igood=3'when the conditions for igood=1 and igood=2 are satisfied'
2065/// \param[out] chi2 chisquare of the test
2066/// \param[out] ndf number of degrees of freedom (important, when both histograms have the same empty bins)
2067/// \param[out] res normalized residuals for further analysis
2068
2069Double_t TH1::Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option, Double_t *res) const
2070{
2071
2072 Int_t i_start, i_end;
2073 Int_t j_start, j_end;
2074 Int_t k_start, k_end;
2075
2076 Double_t sum1 = 0.0, sumw1 = 0.0;
2077 Double_t sum2 = 0.0, sumw2 = 0.0;
2078
2079 chi2 = 0.0;
2080 ndf = 0;
2081
2082 TString opt = option;
2083 opt.ToUpper();
2084
2085 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
2086
2087 const TAxis *xaxis1 = GetXaxis();
2088 const TAxis *xaxis2 = h2->GetXaxis();
2089 const TAxis *yaxis1 = GetYaxis();
2090 const TAxis *yaxis2 = h2->GetYaxis();
2091 const TAxis *zaxis1 = GetZaxis();
2092 const TAxis *zaxis2 = h2->GetZaxis();
2093
2094 Int_t nbinx1 = xaxis1->GetNbins();
2095 Int_t nbinx2 = xaxis2->GetNbins();
2096 Int_t nbiny1 = yaxis1->GetNbins();
2097 Int_t nbiny2 = yaxis2->GetNbins();
2098 Int_t nbinz1 = zaxis1->GetNbins();
2099 Int_t nbinz2 = zaxis2->GetNbins();
2100
2101 //check dimensions
2102 if (this->GetDimension() != h2->GetDimension() ){
2103 Error("Chi2TestX","Histograms have different dimensions.");
2104 return 0.0;
2105 }
2106
2107 //check number of channels
2108 if (nbinx1 != nbinx2) {
2109 Error("Chi2TestX","different number of x channels");
2110 }
2111 if (nbiny1 != nbiny2) {
2112 Error("Chi2TestX","different number of y channels");
2113 }
2114 if (nbinz1 != nbinz2) {
2115 Error("Chi2TestX","different number of z channels");
2116 }
2117
2118 //check for ranges
2119 i_start = j_start = k_start = 1;
2120 i_end = nbinx1;
2121 j_end = nbiny1;
2122 k_end = nbinz1;
2123
2124 if (xaxis1->TestBit(TAxis::kAxisRange)) {
2125 i_start = xaxis1->GetFirst();
2126 i_end = xaxis1->GetLast();
2127 }
2128 if (yaxis1->TestBit(TAxis::kAxisRange)) {
2129 j_start = yaxis1->GetFirst();
2130 j_end = yaxis1->GetLast();
2131 }
2132 if (zaxis1->TestBit(TAxis::kAxisRange)) {
2133 k_start = zaxis1->GetFirst();
2134 k_end = zaxis1->GetLast();
2135 }
2136
2137
2138 if (opt.Contains("OF")) {
2139 if (GetDimension() == 3) k_end = ++nbinz1;
2140 if (GetDimension() >= 2) j_end = ++nbiny1;
2141 if (GetDimension() >= 1) i_end = ++nbinx1;
2142 }
2143
2144 if (opt.Contains("UF")) {
2145 if (GetDimension() == 3) k_start = 0;
2146 if (GetDimension() >= 2) j_start = 0;
2147 if (GetDimension() >= 1) i_start = 0;
2148 }
2149
2150 ndf = (i_end - i_start + 1) * (j_end - j_start + 1) * (k_end - k_start + 1) - 1;
2151
2152 Bool_t comparisonUU = opt.Contains("UU");
2153 Bool_t comparisonUW = opt.Contains("UW");
2154 Bool_t comparisonWW = opt.Contains("WW");
2155 Bool_t scaledHistogram = opt.Contains("NORM");
2156
2157 if (scaledHistogram && !comparisonUU) {
2158 Info("Chi2TestX", "NORM option should be used together with UU option. It is ignored");
2159 }
2160
2161 // look at histo global bin content and effective entries
2162 Stat_t s[kNstat];
2163 GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2164 Double_t sumBinContent1 = s[0];
2165 Double_t effEntries1 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2166
2167 h2->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
2168 Double_t sumBinContent2 = s[0];
2169 Double_t effEntries2 = (s[1] ? s[0] * s[0] / s[1] : 0.0);
2170
2171 if (!comparisonUU && !comparisonUW && !comparisonWW ) {
2172 // deduce automatically from type of histogram
2173 if (TMath::Abs(sumBinContent1 - effEntries1) < 1) {
2174 if ( TMath::Abs(sumBinContent2 - effEntries2) < 1) comparisonUU = true;
2175 else comparisonUW = true;
2176 }
2177 else comparisonWW = true;
2178 }
2179 // check unweighted histogram
2180 if (comparisonUW) {
2181 if (TMath::Abs(sumBinContent1 - effEntries1) >= 1) {
2182 Warning("Chi2TestX","First histogram is not unweighted and option UW has been requested");
2183 }
2184 }
2185 if ( (!scaledHistogram && comparisonUU) ) {
2186 if ( ( TMath::Abs(sumBinContent1 - effEntries1) >= 1) || (TMath::Abs(sumBinContent2 - effEntries2) >= 1) ) {
2187 Warning("Chi2TestX","Both histograms are not unweighted and option UU has been requested");
2188 }
2189 }
2190
2191
2192 //get number of events in histogram
2193 if (comparisonUU && scaledHistogram) {
2194 for (Int_t i = i_start; i <= i_end; ++i) {
2195 for (Int_t j = j_start; j <= j_end; ++j) {
2196 for (Int_t k = k_start; k <= k_end; ++k) {
2197
2198 Int_t bin = GetBin(i, j, k);
2199
2200 Double_t cnt1 = RetrieveBinContent(bin);
2201 Double_t cnt2 = h2->RetrieveBinContent(bin);
2202 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2203 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2204
2205 if (e1sq > 0.0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2206 else cnt1 = 0.0;
2207
2208 if (e2sq > 0.0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2209 else cnt2 = 0.0;
2210
2211 // sum contents
2212 sum1 += cnt1;
2213 sum2 += cnt2;
2214 sumw1 += e1sq;
2215 sumw2 += e2sq;
2216 }
2217 }
2218 }
2219 if (sumw1 <= 0.0 || sumw2 <= 0.0) {
2220 Error("Chi2TestX", "Cannot use option NORM when one histogram has all zero errors");
2221 return 0.0;
2222 }
2223
2224 } else {
2225 for (Int_t i = i_start; i <= i_end; ++i) {
2226 for (Int_t j = j_start; j <= j_end; ++j) {
2227 for (Int_t k = k_start; k <= k_end; ++k) {
2228
2229 Int_t bin = GetBin(i, j, k);
2230
2231 sum1 += RetrieveBinContent(bin);
2232 sum2 += h2->RetrieveBinContent(bin);
2233
2234 if ( comparisonWW ) sumw1 += GetBinErrorSqUnchecked(bin);
2235 if ( comparisonUW || comparisonWW ) sumw2 += h2->GetBinErrorSqUnchecked(bin);
2236 }
2237 }
2238 }
2239 }
2240 //checks that the histograms are not empty
2241 if (sum1 == 0.0 || sum2 == 0.0) {
2242 Error("Chi2TestX","one histogram is empty");
2243 return 0.0;
2244 }
2245
2246 if ( comparisonWW && ( sumw1 <= 0.0 && sumw2 <= 0.0 ) ){
2247 Error("Chi2TestX","Hist1 and Hist2 have both all zero errors\n");
2248 return 0.0;
2249 }
2250
2251 //THE TEST
2252 Int_t m = 0, n = 0;
2253
2254 //Experiment - experiment comparison
2255 if (comparisonUU) {
2256 Double_t sum = sum1 + sum2;
2257 for (Int_t i = i_start; i <= i_end; ++i) {
2258 for (Int_t j = j_start; j <= j_end; ++j) {
2259 for (Int_t k = k_start; k <= k_end; ++k) {
2260
2261 Int_t bin = GetBin(i, j, k);
2262
2263 Double_t cnt1 = RetrieveBinContent(bin);
2264 Double_t cnt2 = h2->RetrieveBinContent(bin);
2265
2266 if (scaledHistogram) {
2267 // scale bin value to effective bin entries
2268 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2269 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2270
2271 if (e1sq > 0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
2272 else cnt1 = 0;
2273
2274 if (e2sq > 0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
2275 else cnt2 = 0;
2276 }
2277
2278 if (Int_t(cnt1) == 0 && Int_t(cnt2) == 0) --ndf; // no data means one degree of freedom less
2279 else {
2280
2281 Double_t cntsum = cnt1 + cnt2;
2282 Double_t nexp1 = cntsum * sum1 / sum;
2283 //Double_t nexp2 = binsum*sum2/sum;
2284
2285 if (res) res[i - i_start] = (cnt1 - nexp1) / TMath::Sqrt(nexp1);
2286
2287 if (cnt1 < 1) ++m;
2288 if (cnt2 < 1) ++n;
2289
2290 //Habermann correction for residuals
2291 Double_t correc = (1. - sum1 / sum) * (1. - cntsum / sum);
2292 if (res) res[i - i_start] /= TMath::Sqrt(correc);
2293
2294 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2295 chi2 += delta * delta / cntsum;
2296 }
2297 }
2298 }
2299 }
2300 chi2 /= sum1 * sum2;
2301
2302 // flag error only when of the two histogram is zero
2303 if (m) {
2304 igood += 1;
2305 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2306 }
2307 if (n) {
2308 igood += 2;
2309 Info("Chi2TestX","There is a bin in h2 with less than 1 event.\n");
2310 }
2311
2312 Double_t prob = TMath::Prob(chi2,ndf);
2313 return prob;
2314
2315 }
2316
2317 // unweighted - weighted comparison
2318 // case of error = 0 and content not zero is treated without problems by excluding second chi2 sum
2319 // and can be considered as a data-theory comparison
2320 if ( comparisonUW ) {
2321 for (Int_t i = i_start; i <= i_end; ++i) {
2322 for (Int_t j = j_start; j <= j_end; ++j) {
2323 for (Int_t k = k_start; k <= k_end; ++k) {
2324
2325 Int_t bin = GetBin(i, j, k);
2326
2327 Double_t cnt1 = RetrieveBinContent(bin);
2328 Double_t cnt2 = h2->RetrieveBinContent(bin);
2329 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2330
2331 // case both histogram have zero bin contents
2332 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2333 --ndf; //no data means one degree of freedom less
2334 continue;
2335 }
2336
2337 // case weighted histogram has zero bin content and error
2338 if (cnt2 * cnt2 == 0 && e2sq == 0) {
2339 if (sumw2 > 0) {
2340 // use as approximated error as 1 scaled by a scaling ratio
2341 // estimated from the total sum weight and sum weight squared
2342 e2sq = sumw2 / sum2;
2343 }
2344 else {
2345 // return error because infinite discrepancy here:
2346 // bin1 != 0 and bin2 =0 in a histogram with all errors zero
2347 Error("Chi2TestX","Hist2 has in bin (%d,%d,%d) zero content and zero errors\n", i, j, k);
2348 chi2 = 0; return 0;
2349 }
2350 }
2351
2352 if (cnt1 < 1) m++;
2353 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2354
2355 Double_t var1 = sum2 * cnt2 - sum1 * e2sq;
2356 Double_t var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2357
2358 // if cnt1 is zero and cnt2 = 1 and sum1 = sum2 var1 = 0 && var2 == 0
2359 // approximate by incrementing cnt1
2360 // LM (this need to be fixed for numerical errors)
2361 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2362 sum1++;
2363 cnt1++;
2364 var1 = sum2 * cnt2 - sum1 * e2sq;
2365 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2366 }
2367 var2 = TMath::Sqrt(var2);
2368
2369 while (var1 + var2 == 0) {
2370 sum1++;
2371 cnt1++;
2372 var1 = sum2 * cnt2 - sum1 * e2sq;
2373 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2374 while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
2375 sum1++;
2376 cnt1++;
2377 var1 = sum2 * cnt2 - sum1 * e2sq;
2378 var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
2379 }
2380 var2 = TMath::Sqrt(var2);
2381 }
2382
2383 Double_t probb = (var1 + var2) / (2. * sum2 * sum2);
2384
2385 Double_t nexp1 = probb * sum1;
2386 Double_t nexp2 = probb * sum2;
2387
2388 Double_t delta1 = cnt1 - nexp1;
2389 Double_t delta2 = cnt2 - nexp2;
2390
2391 chi2 += delta1 * delta1 / nexp1;
2392
2393 if (e2sq > 0) {
2394 chi2 += delta2 * delta2 / e2sq;
2395 }
2396
2397 if (res) {
2398 if (e2sq > 0) {
2399 Double_t temp1 = sum2 * e2sq / var2;
2400 Double_t temp2 = 1.0 + (sum1 * e2sq - sum2 * cnt2) / var2;
2401 temp2 = temp1 * temp1 * sum1 * probb * (1.0 - probb) + temp2 * temp2 * e2sq / 4.0;
2402 // invert sign here
2403 res[i - i_start] = - delta2 / TMath::Sqrt(temp2);
2404 }
2405 else
2406 res[i - i_start] = delta1 / TMath::Sqrt(nexp1);
2407 }
2408 }
2409 }
2410 }
2411
2412 if (m) {
2413 igood += 1;
2414 Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
2415 }
2416 if (n) {
2417 igood += 2;
2418 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2419 }
2420
2421 Double_t prob = TMath::Prob(chi2, ndf);
2422
2423 return prob;
2424 }
2425
2426 // weighted - weighted comparison
2427 if (comparisonWW) {
2428 for (Int_t i = i_start; i <= i_end; ++i) {
2429 for (Int_t j = j_start; j <= j_end; ++j) {
2430 for (Int_t k = k_start; k <= k_end; ++k) {
2431
2432 Int_t bin = GetBin(i, j, k);
2433 Double_t cnt1 = RetrieveBinContent(bin);
2434 Double_t cnt2 = h2->RetrieveBinContent(bin);
2435 Double_t e1sq = GetBinErrorSqUnchecked(bin);
2436 Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);
2437
2438 // case both histogram have zero bin contents
2439 // (use square of content to avoid numerical errors)
2440 if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
2441 --ndf; //no data means one degree of freedom less
2442 continue;
2443 }
2444
2445 if (e1sq == 0 && e2sq == 0) {
2446 // cannot treat case of booth histogram have zero zero errors
2447 Error("Chi2TestX","h1 and h2 both have bin %d,%d,%d with all zero errors\n", i,j,k);
2448 chi2 = 0; return 0;
2449 }
2450
2451 Double_t sigma = sum1 * sum1 * e2sq + sum2 * sum2 * e1sq;
2452 Double_t delta = sum2 * cnt1 - sum1 * cnt2;
2453 chi2 += delta * delta / sigma;
2454
2455 if (res) {
2456 Double_t temp = cnt1 * sum1 * e2sq + cnt2 * sum2 * e1sq;
2457 Double_t probb = temp / sigma;
2458 Double_t z = 0;
2459 if (e1sq > e2sq) {
2460 Double_t d1 = cnt1 - sum1 * probb;
2461 Double_t s1 = e1sq * ( 1. - e2sq * sum1 * sum1 / sigma );
2462 z = d1 / TMath::Sqrt(s1);
2463 }
2464 else {
2465 Double_t d2 = cnt2 - sum2 * probb;
2466 Double_t s2 = e2sq * ( 1. - e1sq * sum2 * sum2 / sigma );
2467 z = -d2 / TMath::Sqrt(s2);
2468 }
2469 res[i - i_start] = z;
2470 }
2471
2472 if (e1sq > 0 && cnt1 * cnt1 / e1sq < 10) m++;
2473 if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
2474 }
2475 }
2476 }
2477 if (m) {
2478 igood += 1;
2479 Info("Chi2TestX","There is a bin in h1 with less than 10 effective events.\n");
2480 }
2481 if (n) {
2482 igood += 2;
2483 Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
2484 }
2485 Double_t prob = TMath::Prob(chi2, ndf);
2486 return prob;
2487 }
2488 return 0;
2489}
2490////////////////////////////////////////////////////////////////////////////////
2491/// Compute and return the chisquare of this histogram with respect to a function
2492/// The chisquare is computed by weighting each histogram point by the bin error
2493/// By default the full range of the histogram is used.
2494/// Use option "R" for restricting the chisquare calculation to the given range of the function
2495/// Use option "L" for using the chisquare based on the poisson likelihood (Baker-Cousins Chisquare)
2496/// Use option "P" for using the Pearson chisquare based on the expected bin errors
2497
2499{
2500 if (!func) {
2501 Error("Chisquare","Function pointer is Null - return -1");
2502 return -1;
2503 }
2504
2505 TString opt(option); opt.ToUpper();
2506 bool useRange = opt.Contains("R");
2507 ROOT::Fit::EChisquareType type = ROOT::Fit::EChisquareType::kNeyman; // default chi2 with observed error
2510
2511 return ROOT::Fit::Chisquare(*this, *func, useRange, type);
2512}
2513
2514////////////////////////////////////////////////////////////////////////////////
2515/// Remove all the content from the underflow and overflow bins, without changing the number of entries
2516/// After calling this method, every undeflow and overflow bins will have content 0.0
2517/// The Sumw2 is also cleared, since there is no more content in the bins
2518
2520{
2521 for (Int_t bin = 0; bin < fNcells; ++bin)
2522 if (IsBinUnderflow(bin) || IsBinOverflow(bin)) {
2523 UpdateBinContent(bin, 0.0);
2524 if (fSumw2.fN) fSumw2.fArray[bin] = 0.0;
2525 }
2526}
2527
2528////////////////////////////////////////////////////////////////////////////////
2529/// Compute integral (normalized cumulative sum of bins) w/o under/overflows
2530/// The result is stored in fIntegral and used by the GetRandom functions.
2531/// This function is automatically called by GetRandom when the fIntegral
2532/// array does not exist or when the number of entries in the histogram
2533/// has changed since the previous call to GetRandom.
2534/// The resulting integral is normalized to 1.
2535/// If the routine is called with the onlyPositive flag set an error will
2536/// be produced in case of negative bin content and a NaN value returned
2537/// \return 1 if success, 0 if integral is zero, NAN if onlyPositive-test fails
2538
2540{
2541 if (fBuffer) BufferEmpty();
2542
2543 // delete previously computed integral (if any)
2544 if (fIntegral) delete [] fIntegral;
2545
2546 // - Allocate space to store the integral and compute integral
2547 Int_t nbinsx = GetNbinsX();
2548 Int_t nbinsy = GetNbinsY();
2549 Int_t nbinsz = GetNbinsZ();
2550 Int_t nbins = nbinsx * nbinsy * nbinsz;
2551
2552 fIntegral = new Double_t[nbins + 2];
2553 Int_t ibin = 0; fIntegral[ibin] = 0;
2554
2555 for (Int_t binz=1; binz <= nbinsz; ++binz) {
2556 for (Int_t biny=1; biny <= nbinsy; ++biny) {
2557 for (Int_t binx=1; binx <= nbinsx; ++binx) {
2558 ++ibin;
2559 Double_t y = RetrieveBinContent(GetBin(binx, biny, binz));
2560 if (onlyPositive && y < 0) {
2561 Error("ComputeIntegral","Bin content is negative - return a NaN value");
2562 fIntegral[nbins] = TMath::QuietNaN();
2563 break;
2564 }
2565 fIntegral[ibin] = fIntegral[ibin - 1] + y;
2566 }
2567 }
2568 }
2569
2570 // - Normalize integral to 1
2571 if (fIntegral[nbins] == 0 ) {
2572 Error("ComputeIntegral", "Integral = 0, no hits in histogram bins (excluding over/underflow).");
2573 return 0;
2574 }
2575 for (Int_t bin=1; bin <= nbins; ++bin) fIntegral[bin] /= fIntegral[nbins];
2576 fIntegral[nbins+1] = fEntries;
2577 return fIntegral[nbins];
2578}
2579
2580////////////////////////////////////////////////////////////////////////////////
2581/// Return a pointer to the array of bins integral.
2582/// if the pointer fIntegral is null, TH1::ComputeIntegral is called
2583/// The array dimension is the number of bins in the histograms
2584/// including underflow and overflow (fNCells)
2585/// the last value integral[fNCells] is set to the number of entries of
2586/// the histogram
2587
2589{
2590 if (!fIntegral) ComputeIntegral();
2591 return fIntegral;
2592}
2593
2594////////////////////////////////////////////////////////////////////////////////
2595/// Return a pointer to a histogram containing the cumulative content.
2596/// The cumulative can be computed both in the forward (default) or backward
2597/// direction; the name of the new histogram is constructed from
2598/// the name of this histogram with the suffix "suffix" appended provided
2599/// by the user. If not provided a default suffix="_cumulative" is used.
2600///
2601/// The cumulative distribution is formed by filling each bin of the
2602/// resulting histogram with the sum of that bin and all previous
2603/// (forward == kTRUE) or following (forward = kFALSE) bins.
2604///
2605/// Note: while cumulative distributions make sense in one dimension, you
2606/// may not be getting what you expect in more than 1D because the concept
2607/// of a cumulative distribution is much trickier to define; make sure you
2608/// understand the order of summation before you use this method with
2609/// histograms of dimension >= 2.
2610///
2611/// Note 2: By default the cumulative is computed from bin 1 to Nbins
2612/// If an axis range is set, values between the minimum and maximum of the range
2613/// are set.
2614/// Setting an axis range can also be used for including underflow and overflow in
2615/// the cumulative (e.g. by setting h->GetXaxis()->SetRange(0, h->GetNbinsX()+1); )
2617
2618TH1 *TH1::GetCumulative(Bool_t forward, const char* suffix) const
2619{
2620 const Int_t firstX = fXaxis.GetFirst();
2621 const Int_t lastX = fXaxis.GetLast();
2622 const Int_t firstY = (fDimension > 1) ? fYaxis.GetFirst() : 1;
2623 const Int_t lastY = (fDimension > 1) ? fYaxis.GetLast() : 1;
2624 const Int_t firstZ = (fDimension > 1) ? fZaxis.GetFirst() : 1;
2625 const Int_t lastZ = (fDimension > 1) ? fZaxis.GetLast() : 1;
2626
2627 TH1* hintegrated = (TH1*) Clone(fName + suffix);
2628 hintegrated->Reset();
2629 Double_t sum = 0.;
2630 Double_t esum = 0;
2631 if (forward) { // Forward computation
2632 for (Int_t binz = firstZ; binz <= lastZ; ++binz) {
2633 for (Int_t biny = firstY; biny <= lastY; ++biny) {
2634 for (Int_t binx = firstX; binx <= lastX; ++binx) {
2635 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2636 sum += RetrieveBinContent(bin);
2637 hintegrated->AddBinContent(bin, sum);
2638 if (fSumw2.fN) {
2639 esum += GetBinErrorSqUnchecked(bin);
2640 hintegrated->fSumw2.fArray[bin] = esum;
2641 }
2642 }
2643 }
2644 }
2645 } else { // Backward computation
2646 for (Int_t binz = lastZ; binz >= firstZ; --binz) {
2647 for (Int_t biny = lastY; biny >= firstY; --biny) {
2648 for (Int_t binx = lastX; binx >= firstX; --binx) {
2649 const Int_t bin = hintegrated->GetBin(binx, biny, binz);
2650 sum += RetrieveBinContent(bin);
2651 hintegrated->AddBinContent(bin, sum);
2652 if (fSumw2.fN) {
2653 esum += GetBinErrorSqUnchecked(bin);
2654 hintegrated->fSumw2.fArray[bin] = esum;
2655 }
2656 }
2657 }
2658 }
2659 }
2660 return hintegrated;
2661}
2662
2663////////////////////////////////////////////////////////////////////////////////
2664/// Copy this histogram structure to newth1.
2665///
2666/// Note that this function does not copy the list of associated functions.
2667/// Use TObject::Clone to make a full copy of a histogram.
2668///
2669/// Note also that the histogram it will be created in gDirectory (if AddDirectoryStatus()=true)
2670/// or will not be added to any directory if AddDirectoryStatus()=false
2671/// independently of the current directory stored in the original histogram
2672
2673void TH1::Copy(TObject &obj) const
2674{
2675 if (((TH1&)obj).fDirectory) {
2676 // We are likely to change the hash value of this object
2677 // with TNamed::Copy, to keep things correct, we need to
2678 // clean up its existing entries.
2679 ((TH1&)obj).fDirectory->Remove(&obj);
2680 ((TH1&)obj).fDirectory = nullptr;
2681 }
2682 TNamed::Copy(obj);
2683 ((TH1&)obj).fDimension = fDimension;
2684 ((TH1&)obj).fNormFactor= fNormFactor;
2685 ((TH1&)obj).fNcells = fNcells;
2686 ((TH1&)obj).fBarOffset = fBarOffset;
2687 ((TH1&)obj).fBarWidth = fBarWidth;
2688 ((TH1&)obj).fOption = fOption;
2689 ((TH1&)obj).fBinStatErrOpt = fBinStatErrOpt;
2690 ((TH1&)obj).fBufferSize= fBufferSize;
2691 // copy the Buffer
2692 // delete first a previously existing buffer
2693 if (((TH1&)obj).fBuffer != nullptr) {
2694 delete [] ((TH1&)obj).fBuffer;
2695 ((TH1&)obj).fBuffer = nullptr;
2696 }
2697 if (fBuffer) {
2698 Double_t *buf = new Double_t[fBufferSize];
2699 for (Int_t i=0;i<fBufferSize;i++) buf[i] = fBuffer[i];
2700 // obj.fBuffer has been deleted before
2701 ((TH1&)obj).fBuffer = buf;
2702 }
2703
2704 // copy bin contents (this should be done by the derived classes, since TH1 does not store the bin content)
2705 // Do this in case derived from TArray
2706 TArray* a = dynamic_cast<TArray*>(&obj);
2707 if (a) {
2708 a->Set(fNcells);
2709 for (Int_t i = 0; i < fNcells; i++)
2711 }
2712
2713 ((TH1&)obj).fEntries = fEntries;
2714
2715 // which will call BufferEmpty(0) and set fBuffer[0] to a Maybe one should call
2716 // assignment operator on the TArrayD
2717
2718 ((TH1&)obj).fTsumw = fTsumw;
2719 ((TH1&)obj).fTsumw2 = fTsumw2;
2720 ((TH1&)obj).fTsumwx = fTsumwx;
2721 ((TH1&)obj).fTsumwx2 = fTsumwx2;
2722 ((TH1&)obj).fMaximum = fMaximum;
2723 ((TH1&)obj).fMinimum = fMinimum;
2724
2725 TAttLine::Copy(((TH1&)obj));
2726 TAttFill::Copy(((TH1&)obj));
2727 TAttMarker::Copy(((TH1&)obj));
2728 fXaxis.Copy(((TH1&)obj).fXaxis);
2729 fYaxis.Copy(((TH1&)obj).fYaxis);
2730 fZaxis.Copy(((TH1&)obj).fZaxis);
2731 ((TH1&)obj).fXaxis.SetParent(&obj);
2732 ((TH1&)obj).fYaxis.SetParent(&obj);
2733 ((TH1&)obj).fZaxis.SetParent(&obj);
2734 fContour.Copy(((TH1&)obj).fContour);
2735 fSumw2.Copy(((TH1&)obj).fSumw2);
2736 // fFunctions->Copy(((TH1&)obj).fFunctions);
2737 // when copying an histogram if the AddDirectoryStatus() is true it
2738 // will be added to gDirectory independently of the fDirectory stored.
2739 // and if the AddDirectoryStatus() is false it will not be added to
2740 // any directory (fDirectory = nullptr)
2741 if (fgAddDirectory && gDirectory) {
2742 gDirectory->Append(&obj);
2743 ((TH1&)obj).fFunctions->UseRWLock();
2744 ((TH1&)obj).fDirectory = gDirectory;
2745 } else
2746 ((TH1&)obj).fDirectory = nullptr;
2747
2748}
2749
2750////////////////////////////////////////////////////////////////////////////////
2751/// Make a complete copy of the underlying object. If 'newname' is set,
2752/// the copy's name will be set to that name.
2753
2754TObject* TH1::Clone(const char* newname) const
2755{
2756 TH1* obj = (TH1*)IsA()->GetNew()(nullptr);
2757 Copy(*obj);
2758
2759 // Now handle the parts that Copy doesn't do
2760 if(fFunctions) {
2761 // The Copy above might have published 'obj' to the ListOfCleanups.
2762 // Clone can call RecursiveRemove, for example via TCheckHashRecursiveRemoveConsistency
2763 // when dictionary information is initialized, so we need to
2764 // keep obj->fFunction valid during its execution and
2765 // protect the update with the write lock.
2766
2767 // Reset stats parent - else cloning the stats will clone this histogram, too.
2768 auto oldstats = dynamic_cast<TVirtualPaveStats*>(fFunctions->FindObject("stats"));
2769 TObject *oldparent = nullptr;
2770 if (oldstats) {
2771 oldparent = oldstats->GetParent();
2772 oldstats->SetParent(nullptr);
2773 }
2774
2775 auto newlist = (TList*)fFunctions->Clone();
2776
2777 if (oldstats)
2778 oldstats->SetParent(oldparent);
2779 auto newstats = dynamic_cast<TVirtualPaveStats*>(obj->fFunctions->FindObject("stats"));
2780 if (newstats)
2781 newstats->SetParent(obj);
2782
2783 auto oldlist = obj->fFunctions;
2784 {
2786 obj->fFunctions = newlist;
2787 }
2788 delete oldlist;
2789 }
2790 if(newname && strlen(newname) ) {
2791 obj->SetName(newname);
2792 }
2793 return obj;
2794}
2795
2796////////////////////////////////////////////////////////////////////////////////
2797/// Perform the automatic addition of the histogram to the given directory
2798///
2799/// Note this function is called in place when the semantic requires
2800/// this object to be added to a directory (I.e. when being read from
2801/// a TKey or being Cloned)
2802
2804{
2805 Bool_t addStatus = TH1::AddDirectoryStatus();
2806 if (addStatus) {
2807 SetDirectory(dir);
2808 if (dir) {
2810 }
2811 }
2812}
2813
2814////////////////////////////////////////////////////////////////////////////////
2815/// Compute distance from point px,py to a line.
2816///
2817/// Compute the closest distance of approach from point px,py to elements
2818/// of a histogram.
2819/// The distance is computed in pixels units.
2820///
2821/// #### Algorithm:
2822/// Currently, this simple model computes the distance from the mouse
2823/// to the histogram contour only.
2824
2826{
2827 if (!fPainter) return 9999;
2828 return fPainter->DistancetoPrimitive(px,py);
2829}
2830
2831////////////////////////////////////////////////////////////////////////////////
2832/// Performs the operation: `this = this/(c1*f1)`
2833/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2834///
2835/// Only bins inside the function range are recomputed.
2836/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2837/// you should call Sumw2 before making this operation.
2838/// This is particularly important if you fit the histogram after TH1::Divide
2839///
2840/// The function return kFALSE if the divide operation failed
2841
2843{
2844 if (!f1) {
2845 Error("Divide","Attempt to divide by a non-existing function");
2846 return kFALSE;
2847 }
2848
2849 // delete buffer if it is there since it will become invalid
2850 if (fBuffer) BufferEmpty(1);
2851
2852 Int_t nx = GetNbinsX() + 2; // normal bins + uf / of
2853 Int_t ny = GetNbinsY() + 2;
2854 Int_t nz = GetNbinsZ() + 2;
2855 if (fDimension < 2) ny = 1;
2856 if (fDimension < 3) nz = 1;
2857
2858
2859 SetMinimum();
2860 SetMaximum();
2861
2862 // - Loop on bins (including underflows/overflows)
2863 Int_t bin, binx, biny, binz;
2864 Double_t cu, w;
2865 Double_t xx[3];
2866 Double_t *params = nullptr;
2867 f1->InitArgs(xx,params);
2868 for (binz = 0; binz < nz; ++binz) {
2869 xx[2] = fZaxis.GetBinCenter(binz);
2870 for (biny = 0; biny < ny; ++biny) {
2871 xx[1] = fYaxis.GetBinCenter(biny);
2872 for (binx = 0; binx < nx; ++binx) {
2873 xx[0] = fXaxis.GetBinCenter(binx);
2874 if (!f1->IsInside(xx)) continue;
2876 bin = binx + nx * (biny + ny * binz);
2877 cu = c1 * f1->EvalPar(xx);
2878 if (TF1::RejectedPoint()) continue;
2879 if (cu) w = RetrieveBinContent(bin) / cu;
2880 else w = 0;
2881 UpdateBinContent(bin, w);
2882 if (fSumw2.fN) {
2883 if (cu != 0) fSumw2.fArray[bin] = GetBinErrorSqUnchecked(bin) / (cu * cu);
2884 else fSumw2.fArray[bin] = 0;
2885 }
2886 }
2887 }
2888 }
2889 ResetStats();
2890 return kTRUE;
2891}
2892
2893////////////////////////////////////////////////////////////////////////////////
2894/// Divide this histogram by h1.
2895///
2896/// `this = this/h1`
2897/// if errors are defined (see TH1::Sumw2), errors are also recalculated.
2898/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
2899/// if not already set.
2900/// The resulting errors are calculated assuming uncorrelated histograms.
2901/// See the other TH1::Divide that gives the possibility to optionally
2902/// compute binomial errors.
2903///
2904/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2905/// you should call Sumw2 before making this operation.
2906/// This is particularly important if you fit the histogram after TH1::Scale
2907///
2908/// The function return kFALSE if the divide operation failed
2909
2910Bool_t TH1::Divide(const TH1 *h1)
2911{
2912 if (!h1) {
2913 Error("Divide", "Input histogram passed does not exist (NULL).");
2914 return kFALSE;
2915 }
2916
2917 // delete buffer if it is there since it will become invalid
2918 if (fBuffer) BufferEmpty(1);
2919
2920 if (LoggedInconsistency("Divide", this, h1) >= kDifferentNumberOfBins) {
2921 return false;
2922 }
2923
2924 // Create Sumw2 if h1 has Sumw2 set
2925 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
2926
2927 // - Loop on bins (including underflows/overflows)
2928 for (Int_t i = 0; i < fNcells; ++i) {
2931 if (c1) UpdateBinContent(i, c0 / c1);
2932 else UpdateBinContent(i, 0);
2933
2934 if(fSumw2.fN) {
2935 if (c1 == 0) { fSumw2.fArray[i] = 0; continue; }
2936 Double_t c1sq = c1 * c1;
2937 fSumw2.fArray[i] = (GetBinErrorSqUnchecked(i) * c1sq + h1->GetBinErrorSqUnchecked(i) * c0 * c0) / (c1sq * c1sq);
2938 }
2939 }
2940 ResetStats();
2941 return kTRUE;
2942}
2943
2944////////////////////////////////////////////////////////////////////////////////
2945/// Replace contents of this histogram by the division of h1 by h2.
2946///
2947/// `this = c1*h1/(c2*h2)`
2948///
2949/// If errors are defined (see TH1::Sumw2), errors are also recalculated
2950/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
2951/// if not already set.
2952/// The resulting errors are calculated assuming uncorrelated histograms.
2953/// However, if option ="B" is specified, Binomial errors are computed.
2954/// In this case c1 and c2 do not make real sense and they are ignored.
2955///
2956/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
2957/// you should call Sumw2 before making this operation.
2958/// This is particularly important if you fit the histogram after TH1::Divide
2959///
2960/// Please note also that in the binomial case errors are calculated using standard
2961/// binomial statistics, which means when b1 = b2, the error is zero.
2962/// If you prefer to have efficiency errors not going to zero when the efficiency is 1, you must
2963/// use the function TGraphAsymmErrors::BayesDivide, which will return an asymmetric and non-zero lower
2964/// error for the case b1=b2.
2965///
2966/// The function return kFALSE if the divide operation failed
2967
2969{
2970
2971 TString opt = option;
2972 opt.ToLower();
2973 Bool_t binomial = kFALSE;
2974 if (opt.Contains("b")) binomial = kTRUE;
2975 if (!h1 || !h2) {
2976 Error("Divide", "At least one of the input histograms passed does not exist (NULL).");
2977 return kFALSE;
2978 }
2979
2980 // delete buffer if it is there since it will become invalid
2981 if (fBuffer) BufferEmpty(1);
2982
2983 if (LoggedInconsistency("Divide", this, h1) >= kDifferentNumberOfBins ||
2984 LoggedInconsistency("Divide", h1, h2) >= kDifferentNumberOfBins) {
2985 return false;
2986 }
2987
2988 if (!c2) {
2989 Error("Divide","Coefficient of dividing histogram cannot be zero");
2990 return kFALSE;
2991 }
2992
2993 // Create Sumw2 if h1 or h2 have Sumw2 set, or if binomial errors are explicitly requested
2994 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0 || binomial)) Sumw2();
2995
2996 SetMinimum();
2997 SetMaximum();
2998
2999 // - Loop on bins (including underflows/overflows)
3000 for (Int_t i = 0; i < fNcells; ++i) {
3002 Double_t b2 = h2->RetrieveBinContent(i);
3003 if (b2) UpdateBinContent(i, c1 * b1 / (c2 * b2));
3004 else UpdateBinContent(i, 0);
3005
3006 if (fSumw2.fN) {
3007 if (b2 == 0) { fSumw2.fArray[i] = 0; continue; }
3008 Double_t b1sq = b1 * b1; Double_t b2sq = b2 * b2;
3009 Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
3011 Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
3012 if (binomial) {
3013 if (b1 != b2) {
3014 // in the case of binomial statistics c1 and c2 must be 1 otherwise it does not make sense
3015 // c1 and c2 are ignored
3016 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));//this is the formula in Hbook/Hoper1
3017 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/b2); // old formula from G. Flucke
3018 // formula which works also for weighted histogram (see http://root-forum.cern.ch/viewtopic.php?t=3753 )
3019 fSumw2.fArray[i] = TMath::Abs( ( (1. - 2.* b1 / b2) * e1sq + b1sq * e2sq / b2sq ) / b2sq );
3020 } else {
3021 //in case b1=b2 error is zero
3022 //use TGraphAsymmErrors::BayesDivide for getting the asymmetric error not equal to zero
3023 fSumw2.fArray[i] = 0;
3024 }
3025 } else {
3026 fSumw2.fArray[i] = c1sq * c2sq * (e1sq * b2sq + e2sq * b1sq) / (c2sq * c2sq * b2sq * b2sq);
3027 }
3028 }
3029 }
3030 ResetStats();
3031 if (binomial)
3032 // in case of binomial division use denominator for number of entries
3033 SetEntries ( h2->GetEntries() );
3034
3035 return kTRUE;
3036}
3037
3038////////////////////////////////////////////////////////////////////////////////
3039/// Draw this histogram with options.
3040///
3041/// Histograms are drawn via the THistPainter class. Each histogram has
3042/// a pointer to its own painter (to be usable in a multithreaded program).
3043/// The same histogram can be drawn with different options in different pads.
3044/// When a histogram drawn in a pad is deleted, the histogram is
3045/// automatically removed from the pad or pads where it was drawn.
3046/// If a histogram is drawn in a pad, then filled again, the new status
3047/// of the histogram will be automatically shown in the pad next time
3048/// the pad is updated. One does not need to redraw the histogram.
3049/// To draw the current version of a histogram in a pad, one can use
3050/// `h->DrawCopy();`
3051/// This makes a clone of the histogram. Once the clone is drawn, the original
3052/// histogram may be modified or deleted without affecting the aspect of the
3053/// clone.
3054/// By default, TH1::Draw clears the current pad.
3055///
3056/// One can use TH1::SetMaximum and TH1::SetMinimum to force a particular
3057/// value for the maximum or the minimum scale on the plot.
3058///
3059/// TH1::UseCurrentStyle can be used to change all histogram graphics
3060/// attributes to correspond to the current selected style.
3061/// This function must be called for each histogram.
3062/// In case one reads and draws many histograms from a file, one can force
3063/// the histograms to inherit automatically the current graphics style
3064/// by calling before gROOT->ForceStyle();
3065///
3066/// See the THistPainter class for a description of all the drawing options.
3067
3069{
3070 TString opt1 = option; opt1.ToLower();
3071 TString opt2 = option;
3072 Int_t index = opt1.Index("same");
3073
3074 // Check if the string "same" is part of a TCutg name.
3075 if (index>=0) {
3076 Int_t indb = opt1.Index("[");
3077 if (indb>=0) {
3078 Int_t indk = opt1.Index("]");
3079 if (index>indb && index<indk) index = -1;
3080 }
3081 }
3082
3083 // If there is no pad or an empty pad the "same" option is ignored.
3084 if (gPad) {
3085 if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
3086 if (index>=0) {
3087 if (gPad->GetX1() == 0 && gPad->GetX2() == 1 &&
3088 gPad->GetY1() == 0 && gPad->GetY2() == 1 &&
3089 gPad->GetListOfPrimitives()->GetSize()==0) opt2.Remove(index,4);
3090 } else {
3091 //the following statement is necessary in case one attempts to draw
3092 //a temporary histogram already in the current pad
3093 if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this);
3094 gPad->Clear();
3095 }
3096 gPad->IncrementPaletteColor(1, opt1);
3097 } else {
3098 if (index>=0) opt2.Remove(index,4);
3099 }
3100
3101 AppendPad(opt2.Data());
3102}
3103
3104////////////////////////////////////////////////////////////////////////////////
3105/// Copy this histogram and Draw in the current pad.
3106///
3107/// Once the histogram is drawn into the pad, any further modification
3108/// using graphics input will be made on the copy of the histogram,
3109/// and not to the original object.
3110/// By default a postfix "_copy" is added to the histogram name. Pass an empty postfix in case
3111/// you want to draw a histogram with the same name
3112///
3113/// See Draw for the list of options
3114
3115TH1 *TH1::DrawCopy(Option_t *option, const char * name_postfix) const
3116{
3117 TString opt = option;
3118 opt.ToLower();
3119 if (gPad && !opt.Contains("same")) gPad->Clear();
3120 TString newName;
3121 if (name_postfix) newName.Form("%s%s", GetName(), name_postfix);
3122 TH1 *newth1 = (TH1 *)Clone(newName.Data());
3123 newth1->SetDirectory(nullptr);
3124 newth1->SetBit(kCanDelete);
3125 if (gPad) gPad->IncrementPaletteColor(1, opt);
3126
3127 newth1->AppendPad(option);
3128 return newth1;
3129}
3130
3131////////////////////////////////////////////////////////////////////////////////
3132/// Draw a normalized copy of this histogram.
3133///
3134/// A clone of this histogram is normalized to norm and drawn with option.
3135/// A pointer to the normalized histogram is returned.
3136/// The contents of the histogram copy are scaled such that the new
3137/// sum of weights (excluding under and overflow) is equal to norm.
3138/// Note that the returned normalized histogram is not added to the list
3139/// of histograms in the current directory in memory.
3140/// It is the user's responsibility to delete this histogram.
3141/// The kCanDelete bit is set for the returned object. If a pad containing
3142/// this copy is cleared, the histogram will be automatically deleted.
3143///
3144/// See Draw for the list of options
3145
3147{
3149 if (sum == 0) {
3150 Error("DrawNormalized","Sum of weights is null. Cannot normalize histogram: %s",GetName());
3151 return nullptr;
3152 }
3153 Bool_t addStatus = TH1::AddDirectoryStatus();
3155 TH1 *h = (TH1*)Clone();
3157 // in case of drawing with error options - scale correctly the error
3158 TString opt(option); opt.ToUpper();
3159 if (fSumw2.fN == 0) {
3160 h->Sumw2();
3161 // do not use in this case the "Error option " for drawing which is enabled by default since the normalized histogram has now errors
3162 if (opt.IsNull() || opt == "SAME") opt += "HIST";
3163 }
3164 h->Scale(norm/sum);
3165 if (TMath::Abs(fMaximum+1111) > 1e-3) h->SetMaximum(fMaximum*norm/sum);
3166 if (TMath::Abs(fMinimum+1111) > 1e-3) h->SetMinimum(fMinimum*norm/sum);
3167 h->Draw(opt);
3168 TH1::AddDirectory(addStatus);
3169 return h;
3170}
3171
3172////////////////////////////////////////////////////////////////////////////////
3173/// Display a panel with all histogram drawing options.
3174///
3175/// See class TDrawPanelHist for example
3176
3177void TH1::DrawPanel()
3178{
3179 if (!fPainter) {Draw(); if (gPad) gPad->Update();}
3180 if (fPainter) fPainter->DrawPanel();
3181}
3182
3183////////////////////////////////////////////////////////////////////////////////
3184/// Evaluate function f1 at the center of bins of this histogram.
3185///
3186/// - If option "R" is specified, the function is evaluated only
3187/// for the bins included in the function range.
3188/// - If option "A" is specified, the value of the function is added to the
3189/// existing bin contents
3190/// - If option "S" is specified, the value of the function is used to
3191/// generate a value, distributed according to the Poisson
3192/// distribution, with f1 as the mean.
3193
3195{
3196 Double_t x[3];
3197 Int_t range, stat, add;
3198 if (!f1) return;
3199
3200 TString opt = option;
3201 opt.ToLower();
3202 if (opt.Contains("a")) add = 1;
3203 else add = 0;
3204 if (opt.Contains("s")) stat = 1;
3205 else stat = 0;
3206 if (opt.Contains("r")) range = 1;
3207 else range = 0;
3208
3209 // delete buffer if it is there since it will become invalid
3210 if (fBuffer) BufferEmpty(1);
3211
3212 Int_t nbinsx = fXaxis.GetNbins();
3213 Int_t nbinsy = fYaxis.GetNbins();
3214 Int_t nbinsz = fZaxis.GetNbins();
3215 if (!add) Reset();
3216
3217 for (Int_t binz = 1; binz <= nbinsz; ++binz) {
3218 x[2] = fZaxis.GetBinCenter(binz);
3219 for (Int_t biny = 1; biny <= nbinsy; ++biny) {
3220 x[1] = fYaxis.GetBinCenter(biny);
3221 for (Int_t binx = 1; binx <= nbinsx; ++binx) {
3222 Int_t bin = GetBin(binx,biny,binz);
3223 x[0] = fXaxis.GetBinCenter(binx);
3224 if (range && !f1->IsInside(x)) continue;
3225 Double_t fu = f1->Eval(x[0], x[1], x[2]);
3226 if (stat) fu = gRandom->PoissonD(fu);
3227 AddBinContent(bin, fu);
3228 if (fSumw2.fN) fSumw2.fArray[bin] += TMath::Abs(fu);
3229 }
3230 }
3231 }
3232}
3233
3234////////////////////////////////////////////////////////////////////////////////
3235/// Execute action corresponding to one event.
3236///
3237/// This member function is called when a histogram is clicked with the locator
3238///
3239/// If Left button clicked on the bin top value, then the content of this bin
3240/// is modified according to the new position of the mouse when it is released.
3241
3242void TH1::ExecuteEvent(Int_t event, Int_t px, Int_t py)
3243{
3244 if (fPainter) fPainter->ExecuteEvent(event, px, py);
3245}
3246
3247////////////////////////////////////////////////////////////////////////////////
3248/// This function allows to do discrete Fourier transforms of TH1 and TH2.
3249/// Available transform types and flags are described below.
3250///
3251/// To extract more information about the transform, use the function
3252/// TVirtualFFT::GetCurrentTransform() to get a pointer to the current
3253/// transform object.
3254///
3255/// \param[out] h_output histogram for the output. If a null pointer is passed, a new histogram is created
3256/// and returned, otherwise, the provided histogram is used and should be big enough
3257/// \param[in] option option parameters consists of 3 parts:
3258/// - option on what to return
3259/// - "RE" - returns a histogram of the real part of the output
3260/// - "IM" - returns a histogram of the imaginary part of the output
3261/// - "MAG"- returns a histogram of the magnitude of the output
3262/// - "PH" - returns a histogram of the phase of the output
3263/// - option of transform type
3264/// - "R2C" - real to complex transforms - default
3265/// - "R2HC" - real to halfcomplex (special format of storing output data,
3266/// results the same as for R2C)
3267/// - "DHT" - discrete Hartley transform
3268/// real to real transforms (sine and cosine):
3269/// - "R2R_0", "R2R_1", "R2R_2", "R2R_3" - discrete cosine transforms of types I-IV
3270/// - "R2R_4", "R2R_5", "R2R_6", "R2R_7" - discrete sine transforms of types I-IV
3271/// To specify the type of each dimension of a 2-dimensional real to real
3272/// transform, use options of form "R2R_XX", for example, "R2R_02" for a transform,
3273/// which is of type "R2R_0" in 1st dimension and "R2R_2" in the 2nd.
3274/// - option of transform flag
3275/// - "ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal
3276/// performance
3277/// - "M" (from "measure") - some time spend in finding the optimal way to do the transform
3278/// - "P" (from "patient") - more time spend in finding the optimal way to do the transform
3279/// - "EX" (from "exhaustive") - the most optimal way is found
3280/// This option should be chosen depending on how many transforms of the same size and
3281/// type are going to be done. Planning is only done once, for the first transform of this
3282/// size and type. Default is "ES".
3283///
3284/// Examples of valid options: "Mag R2C M" "Re R2R_11" "Im R2C ES" "PH R2HC EX"
3285
3286TH1* TH1::FFT(TH1* h_output, Option_t *option)
3287{
3288
3289 Int_t ndim[3];
3290 ndim[0] = this->GetNbinsX();
3291 ndim[1] = this->GetNbinsY();
3292 ndim[2] = this->GetNbinsZ();
3293
3294 TVirtualFFT *fft;
3295 TString opt = option;
3296 opt.ToUpper();
3297 if (!opt.Contains("2R")){
3298 if (!opt.Contains("2C") && !opt.Contains("2HC") && !opt.Contains("DHT")) {
3299 //no type specified, "R2C" by default
3300 opt.Append("R2C");
3301 }
3302 fft = TVirtualFFT::FFT(this->GetDimension(), ndim, opt.Data());
3303 }
3304 else {
3305 //find the kind of transform
3306 Int_t ind = opt.Index("R2R", 3);
3307 Int_t *kind = new Int_t[2];
3308 char t;
3309 t = opt[ind+4];
3310 kind[0] = atoi(&t);
3311 if (h_output->GetDimension()>1) {
3312 t = opt[ind+5];
3313 kind[1] = atoi(&t);
3314 }
3315 fft = TVirtualFFT::SineCosine(this->GetDimension(), ndim, kind, option);
3316 delete [] kind;
3317 }
3318
3319 if (!fft) return nullptr;
3320 Int_t in=0;
3321 for (Int_t binx = 1; binx<=ndim[0]; binx++) {
3322 for (Int_t biny=1; biny<=ndim[1]; biny++) {
3323 for (Int_t binz=1; binz<=ndim[2]; binz++) {
3324 fft->SetPoint(in, this->GetBinContent(binx, biny, binz));
3325 in++;
3326 }
3327 }
3328 }
3329 fft->Transform();
3330 h_output = TransformHisto(fft, h_output, option);
3331 return h_output;
3332}
3333
3334////////////////////////////////////////////////////////////////////////////////
3335/// Increment bin with abscissa X by 1.
3336///
3337/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3338/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3339///
3340/// If the storage of the sum of squares of weights has been triggered,
3341/// via the function Sumw2, then the sum of the squares of weights is incremented
3342/// by 1 in the bin corresponding to x.
3343///
3344/// The function returns the corresponding bin number which has its content incremented by 1
3345
3347{
3348 if (fBuffer) return BufferFill(x,1);
3349
3350 Int_t bin;
3351 fEntries++;
3352 bin =fXaxis.FindBin(x);
3353 if (bin <0) return -1;
3354 AddBinContent(bin);
3355 if (fSumw2.fN) ++fSumw2.fArray[bin];
3356 if (bin == 0 || bin > fXaxis.GetNbins()) {
3357 if (!GetStatOverflowsBehaviour()) return -1;
3358 }
3359 ++fTsumw;
3360 ++fTsumw2;
3361 fTsumwx += x;
3362 fTsumwx2 += x*x;
3363 return bin;
3364}
3365
3366////////////////////////////////////////////////////////////////////////////////
3367/// Increment bin with abscissa X with a weight w.
3368///
3369/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3370/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3371///
3372/// If the weight is not equal to 1, the storage of the sum of squares of
3373/// weights is automatically triggered and the sum of the squares of weights is incremented
3374/// by \f$ w^2 \f$ in the bin corresponding to x.
3375///
3376/// The function returns the corresponding bin number which has its content incremented by w
3377
3379{
3380
3381 if (fBuffer) return BufferFill(x,w);
3382
3383 Int_t bin;
3384 fEntries++;
3385 bin =fXaxis.FindBin(x);
3386 if (bin <0) return -1;
3387 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW) ) Sumw2(); // must be called before AddBinContent
3388 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3389 AddBinContent(bin, w);
3390 if (bin == 0 || bin > fXaxis.GetNbins()) {
3391 if (!GetStatOverflowsBehaviour()) return -1;
3392 }
3393 Double_t z= w;
3394 fTsumw += z;
3395 fTsumw2 += z*z;
3396 fTsumwx += z*x;
3397 fTsumwx2 += z*x*x;
3398 return bin;
3399}
3400
3401////////////////////////////////////////////////////////////////////////////////
3402/// Increment bin with namex with a weight w
3403///
3404/// if x is less than the low-edge of the first bin, the Underflow bin is incremented
3405/// if x is equal to or greater than the upper edge of last bin, the Overflow bin is incremented
3406///
3407/// If the weight is not equal to 1, the storage of the sum of squares of
3408/// weights is automatically triggered and the sum of the squares of weights is incremented
3409/// by \f$ w^2 \f$ in the bin corresponding to x.
3410///
3411/// The function returns the corresponding bin number which has its content
3412/// incremented by w.
3413
3414Int_t TH1::Fill(const char *namex, Double_t w)
3415{
3416 Int_t bin;
3417 fEntries++;
3418 bin =fXaxis.FindBin(namex);
3419 if (bin <0) return -1;
3420 if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3421 if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
3422 AddBinContent(bin, w);
3423 if (bin == 0 || bin > fXaxis.GetNbins()) return -1;
3424 Double_t z= w;
3425 fTsumw += z;
3426 fTsumw2 += z*z;
3427 // this make sense if the histogram is not expanding (the x axis cannot be extended)
3428 if (!fXaxis.CanExtend() || !fXaxis.IsAlphanumeric()) {
3430 fTsumwx += z*x;
3431 fTsumwx2 += z*x*x;
3432 }
3433 return bin;
3434}
3435
3436////////////////////////////////////////////////////////////////////////////////
3437/// Fill this histogram with an array x and weights w.
3438///
3439/// \param[in] ntimes number of entries in arrays x and w (array size must be ntimes*stride)
3440/// \param[in] x array of values to be histogrammed
3441/// \param[in] w array of weighs
3442/// \param[in] stride step size through arrays x and w
3443///
3444/// If the weight is not equal to 1, the storage of the sum of squares of
3445/// weights is automatically triggered and the sum of the squares of weights is incremented
3446/// by \f$ w^2 \f$ in the bin corresponding to x.
3447/// if w is NULL each entry is assumed a weight=1
3448
3449void TH1::FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3450{
3451 //If a buffer is activated, fill buffer
3452 if (fBuffer) {
3453 ntimes *= stride;
3454 Int_t i = 0;
3455 for (i=0;i<ntimes;i+=stride) {
3456 if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty
3457 if (w) BufferFill(x[i],w[i]);
3458 else BufferFill(x[i], 1.);
3459 }
3460 // fill the remaining entries if the buffer has been deleted
3461 if (i < ntimes && !fBuffer) {
3462 auto weights = w ? &w[i] : nullptr;
3463 DoFillN((ntimes-i)/stride,&x[i],weights,stride);
3464 }
3465 return;
3466 }
3467 // call internal method
3468 DoFillN(ntimes, x, w, stride);
3469}
3470
3471////////////////////////////////////////////////////////////////////////////////
3472/// Internal method to fill histogram content from a vector
3473/// called directly by TH1::BufferEmpty
3474
3475void TH1::DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
3476{
3477 Int_t bin,i;
3478
3479 fEntries += ntimes;
3480 Double_t ww = 1;
3481 Int_t nbins = fXaxis.GetNbins();
3482 ntimes *= stride;
3483 for (i=0;i<ntimes;i+=stride) {
3484 bin =fXaxis.FindBin(x[i]);
3485 if (bin <0) continue;
3486 if (w) ww = w[i];
3487 if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
3488 if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
3489 AddBinContent(bin, ww);
3490 if (bin == 0 || bin > nbins) {
3491 if (!GetStatOverflowsBehaviour()) continue;
3492 }
3493 Double_t z= ww;
3494 fTsumw += z;
3495 fTsumw2 += z*z;
3496 fTsumwx += z*x[i];
3497 fTsumwx2 += z*x[i]*x[i];
3498 }
3499}
3500
3501////////////////////////////////////////////////////////////////////////////////
3502/// Fill histogram following distribution in function fname.
3503///
3504/// @param fname : Function name used for filling the histogram
3505/// @param ntimes : number of times the histogram is filled
3506/// @param rng : (optional) Random number generator used to sample
3507///
3508///
3509/// The distribution contained in the function fname (TF1) is integrated
3510/// over the channel contents for the bin range of this histogram.
3511/// It is normalized to 1.
3512///
3513/// Getting one random number implies:
3514/// - Generating a random number between 0 and 1 (say r1)
3515/// - Look in which bin in the normalized integral r1 corresponds to
3516/// - Fill histogram channel
3517/// ntimes random numbers are generated
3518///
3519/// One can also call TF1::GetRandom to get a random variate from a function.
3520
3521void TH1::FillRandom(const char *fname, Int_t ntimes, TRandom * rng)
3522{
3523 Int_t bin, binx, ibin, loop;
3524 Double_t r1, x;
3525 // - Search for fname in the list of ROOT defined functions
3526 TF1 *f1 = (TF1*)gROOT->GetFunction(fname);
3527 if (!f1) { Error("FillRandom", "Unknown function: %s",fname); return; }
3528
3529 // - Allocate temporary space to store the integral and compute integral
3530
3531 TAxis * xAxis = &fXaxis;
3532
3533 // in case axis of histogram is not defined use the function axis
3534 if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
3536 f1->GetRange(xmin,xmax);
3537 Info("FillRandom","Using function axis and range [%g,%g]",xmin, xmax);
3538 xAxis = f1->GetHistogram()->GetXaxis();
3539 }
3540
3541 Int_t first = xAxis->GetFirst();
3542 Int_t last = xAxis->GetLast();
3543 Int_t nbinsx = last-first+1;
3544
3545 Double_t *integral = new Double_t[nbinsx+1];
3546 integral[0] = 0;
3547 for (binx=1;binx<=nbinsx;binx++) {
3548 Double_t fint = f1->Integral(xAxis->GetBinLowEdge(binx+first-1),xAxis->GetBinUpEdge(binx+first-1), 0.);
3549 integral[binx] = integral[binx-1] + fint;
3550 }
3551
3552 // - Normalize integral to 1
3553 if (integral[nbinsx] == 0 ) {
3554 delete [] integral;
3555 Error("FillRandom", "Integral = zero"); return;
3556 }
3557 for (bin=1;bin<=nbinsx;bin++) integral[bin] /= integral[nbinsx];
3558
3559 // --------------Start main loop ntimes
3560 for (loop=0;loop<ntimes;loop++) {
3561 r1 = (rng) ? rng->Rndm() : gRandom->Rndm();
3562 ibin = TMath::BinarySearch(nbinsx,&integral[0],r1);
3563 //binx = 1 + ibin;
3564 //x = xAxis->GetBinCenter(binx); //this is not OK when SetBuffer is used
3565 x = xAxis->GetBinLowEdge(ibin+first)
3566 +xAxis->GetBinWidth(ibin+first)*(r1-integral[ibin])/(integral[ibin+1] - integral[ibin]);
3567 Fill(x);
3568 }
3569 delete [] integral;
3570}
3571
3572////////////////////////////////////////////////////////////////////////////////
3573/// Fill histogram following distribution in histogram h.
3574///
3575/// @param h : Histogram pointer used for sampling random number
3576/// @param ntimes : number of times the histogram is filled
3577/// @param rng : (optional) Random number generator used for sampling
3578///
3579/// The distribution contained in the histogram h (TH1) is integrated
3580/// over the channel contents for the bin range of this histogram.
3581/// It is normalized to 1.
3582///
3583/// Getting one random number implies:
3584/// - Generating a random number between 0 and 1 (say r1)
3585/// - Look in which bin in the normalized integral r1 corresponds to
3586/// - Fill histogram channel ntimes random numbers are generated
3587///
3588/// SPECIAL CASE when the target histogram has the same binning as the source.
3589/// in this case we simply use a poisson distribution where
3590/// the mean value per bin = bincontent/integral.
3591
3592void TH1::FillRandom(TH1 *h, Int_t ntimes, TRandom * rng)
3593{
3594 if (!h) { Error("FillRandom", "Null histogram"); return; }
3595 if (fDimension != h->GetDimension()) {
3596 Error("FillRandom", "Histograms with different dimensions"); return;
3597 }
3598 if (std::isnan(h->ComputeIntegral(true))) {
3599 Error("FillRandom", "Histograms contains negative bins, does not represent probabilities");
3600 return;
3601 }
3602
3603 //in case the target histogram has the same binning and ntimes much greater
3604 //than the number of bins we can use a fast method
3605 Int_t first = fXaxis.GetFirst();
3606 Int_t last = fXaxis.GetLast();
3607 Int_t nbins = last-first+1;
3608 if (ntimes > 10*nbins) {
3609 auto inconsistency = CheckConsistency(this,h);
3610 if (inconsistency != kFullyConsistent) return; // do nothing
3611 Double_t sumw = h->Integral(first,last);
3612 if (sumw == 0) return;
3613 Double_t sumgen = 0;
3614 for (Int_t bin=first;bin<=last;bin++) {
3615 Double_t mean = h->RetrieveBinContent(bin)*ntimes/sumw;
3616 Double_t cont = (rng) ? rng->Poisson(mean) : gRandom->Poisson(mean);
3617 sumgen += cont;
3618 AddBinContent(bin,cont);
3619 if (fSumw2.fN) fSumw2.fArray[bin] += cont;
3620 }
3621
3622 // fix for the fluctuations in the total number n
3623 // since we use Poisson instead of multinomial
3624 // add a correction to have ntimes as generated entries
3625 Int_t i;
3626 if (sumgen < ntimes) {
3627 // add missing entries
3628 for (i = Int_t(sumgen+0.5); i < ntimes; ++i)
3629 {
3630 Double_t x = h->GetRandom();
3631 Fill(x);
3632 }
3633 }
3634 else if (sumgen > ntimes) {
3635 // remove extra entries
3636 i = Int_t(sumgen+0.5);
3637 while( i > ntimes) {
3638 Double_t x = h->GetRandom(rng);
3639 Int_t ibin = fXaxis.FindBin(x);
3641 // skip in case bin is empty
3642 if (y > 0) {
3643 SetBinContent(ibin, y-1.);
3644 i--;
3645 }
3646 }
3647 }
3648
3649 ResetStats();
3650 return;
3651 }
3652 // case of different axis and not too large ntimes
3653
3654 if (h->ComputeIntegral() ==0) return;
3655 Int_t loop;
3656 Double_t x;
3657 for (loop=0;loop<ntimes;loop++) {
3658 x = h->GetRandom();
3659 Fill(x);
3660 }
3661}
3662
3663////////////////////////////////////////////////////////////////////////////////
3664/// Return Global bin number corresponding to x,y,z
3665///
3666/// 2-D and 3-D histograms are represented with a one dimensional
3667/// structure. This has the advantage that all existing functions, such as
3668/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
3669/// This function tries to extend the axis if the given point belongs to an
3670/// under-/overflow bin AND if CanExtendAllAxes() is true.
3671///
3672/// See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin
3673
3675{
3676 if (GetDimension() < 2) {
3677 return fXaxis.FindBin(x);
3678 }
3679 if (GetDimension() < 3) {
3680 Int_t nx = fXaxis.GetNbins()+2;
3681 Int_t binx = fXaxis.FindBin(x);
3682 Int_t biny = fYaxis.FindBin(y);
3683 return binx + nx*biny;
3684 }
3685 if (GetDimension() < 4) {
3686 Int_t nx = fXaxis.GetNbins()+2;
3687 Int_t ny = fYaxis.GetNbins()+2;
3688 Int_t binx = fXaxis.FindBin(x);
3689 Int_t biny = fYaxis.FindBin(y);
3690 Int_t binz = fZaxis.FindBin(z);
3691 return binx + nx*(biny +ny*binz);
3692 }
3693 return -1;
3694}
3695
3696////////////////////////////////////////////////////////////////////////////////
3697/// Return Global bin number corresponding to x,y,z.
3698///
3699/// 2-D and 3-D histograms are represented with a one dimensional
3700/// structure. This has the advantage that all existing functions, such as
3701/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
3702/// This function DOES NOT try to extend the axis if the given point belongs
3703/// to an under-/overflow bin.
3704///
3705/// See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin
3706
3708{
3709 if (GetDimension() < 2) {
3710 return fXaxis.FindFixBin(x);
3711 }
3712 if (GetDimension() < 3) {
3713 Int_t nx = fXaxis.GetNbins()+2;
3714 Int_t binx = fXaxis.FindFixBin(x);
3715 Int_t biny = fYaxis.FindFixBin(y);
3716 return binx + nx*biny;
3717 }
3718 if (GetDimension() < 4) {
3719 Int_t nx = fXaxis.GetNbins()+2;
3720 Int_t ny = fYaxis.GetNbins()+2;
3721 Int_t binx = fXaxis.FindFixBin(x);
3722 Int_t biny = fYaxis.FindFixBin(y);
3723 Int_t binz = fZaxis.FindFixBin(z);
3724 return binx + nx*(biny +ny*binz);
3725 }
3726 return -1;
3727}
3728
3729////////////////////////////////////////////////////////////////////////////////
3730/// Find first bin with content > threshold for axis (1=x, 2=y, 3=z)
3731/// if no bins with content > threshold is found the function returns -1.
3732/// The search will occur between the specified first and last bin. Specifying
3733/// the value of the last bin to search to less than zero will search until the
3734/// last defined bin.
3735
3736Int_t TH1::FindFirstBinAbove(Double_t threshold, Int_t axis, Int_t firstBin, Int_t lastBin) const
3737{
3738 if (fBuffer) ((TH1*)this)->BufferEmpty();
3739
3740 if (axis < 1 || (axis > 1 && GetDimension() == 1 ) ||
3741 ( axis > 2 && GetDimension() == 2 ) || ( axis > 3 && GetDimension() > 3 ) ) {
3742 Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
3743 axis = 1;
3744 }
3745 if (firstBin < 1) {
3746 firstBin = 1;
3747 }
3748 Int_t nbinsx = fXaxis.GetNbins();
3749 Int_t nbinsy = (GetDimension() > 1 ) ? fYaxis.GetNbins() : 1;
3750 Int_t nbinsz = (GetDimension() > 2 ) ? fZaxis.GetNbins() : 1;
3751
3752 if (axis == 1) {
3753 if (lastBin < 0 || lastBin > fXaxis.GetNbins()) {
3754 lastBin = fXaxis.GetNbins();
3755 }
3756 for (Int_t binx = firstBin; binx <= lastBin; binx++) {
3757 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3758 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3759 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return binx;
3760 }
3761 }
3762 }
3763 }
3764 else if (axis == 2) {
3765 if (lastBin < 0 || lastBin > fYaxis.GetNbins()) {
3766 lastBin = fYaxis.GetNbins();
3767 }
3768 for (Int_t biny = firstBin; biny <= lastBin; biny++) {
3769 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3770 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3771 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return biny;
3772 }
3773 }
3774 }
3775 }
3776 else if (axis == 3) {
3777 if (lastBin < 0 || lastBin > fZaxis.GetNbins()) {
3778 lastBin = fZaxis.GetNbins();
3779 }
3780 for (Int_t binz = firstBin; binz <= lastBin; binz++) {
3781 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3782 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3783 if (RetrieveBinContent(GetBin(binx,biny,binz)) > threshold) return binz;
3784 }
3785 }
3786 }
3787 }
3788
3789 return -1;
3790}
3791
3792////////////////////////////////////////////////////////////////////////////////
3793/// Find last bin with content > threshold for axis (1=x, 2=y, 3=z)
3794/// if no bins with content > threshold is found the function returns -1.
3795/// The search will occur between the specified first and last bin. Specifying
3796/// the value of the last bin to search to less than zero will search until the
3797/// last defined bin.
3798
3799Int_t TH1::FindLastBinAbove(Double_t threshold, Int_t axis, Int_t firstBin, Int_t lastBin) const
3800{
3801 if (fBuffer) ((TH1*)this)->BufferEmpty();
3802
3803
3804 if (axis < 1 || ( axis > 1 && GetDimension() == 1 ) ||
3805 ( axis > 2 && GetDimension() == 2 ) || ( axis > 3 && GetDimension() > 3) ) {
3806 Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
3807 axis = 1;
3808 }
3809 if (firstBin < 1) {
3810 firstBin = 1;
3811 }
3812 Int_t nbinsx = fXaxis.GetNbins();
3813 Int_t nbinsy = (GetDimension() > 1 ) ? fYaxis.GetNbins() : 1;
3814 Int_t nbinsz = (GetDimension() > 2 ) ? fZaxis.GetNbins() : 1;
3815
3816 if (axis == 1) {
3817 if (lastBin < 0 || lastBin > fXaxis.GetNbins()) {
3818 lastBin = fXaxis.GetNbins();
3819 }
3820 for (Int_t binx = lastBin; binx >= firstBin; binx--) {
3821 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3822 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3823 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return binx;
3824 }
3825 }
3826 }
3827 }
3828 else if (axis == 2) {
3829 if (lastBin < 0 || lastBin > fYaxis.GetNbins()) {
3830 lastBin = fYaxis.GetNbins();
3831 }
3832 for (Int_t biny = lastBin; biny >= firstBin; biny--) {
3833 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3834 for (Int_t binz = 1; binz <= nbinsz; binz++) {
3835 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return biny;
3836 }
3837 }
3838 }
3839 }
3840 else if (axis == 3) {
3841 if (lastBin < 0 || lastBin > fZaxis.GetNbins()) {
3842 lastBin = fZaxis.GetNbins();
3843 }
3844 for (Int_t binz = lastBin; binz >= firstBin; binz--) {
3845 for (Int_t binx = 1; binx <= nbinsx; binx++) {
3846 for (Int_t biny = 1; biny <= nbinsy; biny++) {
3847 if (RetrieveBinContent(GetBin(binx, biny, binz)) > threshold) return binz;
3848 }
3849 }
3850 }
3851 }
3852
3853 return -1;
3854}
3855
3856////////////////////////////////////////////////////////////////////////////////
3857/// Search object named name in the list of functions.
3858
3859TObject *TH1::FindObject(const char *name) const
3860{
3861 if (fFunctions) return fFunctions->FindObject(name);
3862 return nullptr;
3863}
3864
3865////////////////////////////////////////////////////////////////////////////////
3866/// Search object obj in the list of functions.
3867
3868TObject *TH1::FindObject(const TObject *obj) const
3869{
3870 if (fFunctions) return fFunctions->FindObject(obj);
3871 return nullptr;
3872}
3873
3874////////////////////////////////////////////////////////////////////////////////
3875/// Fit histogram with function fname.
3876///
3877///
3878/// fname is the name of a function available in the global ROOT list of functions
3879/// `gROOT->GetListOfFunctions`
3880/// The list include any TF1 object created by the user plus some pre-defined functions
3881/// which are automatically created by ROOT the first time a pre-defined function is requested from `gROOT`
3882/// (i.e. when calling `gROOT->GetFunction(const char *name)`).
3883/// These pre-defined functions are:
3884/// - `gaus, gausn` where gausn is the normalized Gaussian
3885/// - `landau, landaun`
3886/// - `expo`
3887/// - `pol1,...9, chebyshev1,...9`.
3888///
3889/// For printing the list of all available functions do:
3890///
3891/// TF1::InitStandardFunctions(); // not needed if `gROOT->GetFunction` is called before
3892/// gROOT->GetListOfFunctions()->ls()
3893///
3894/// `fname` can also be a formula that is accepted by the linear fitter containing the special operator `++`,
3895/// representing linear components separated by `++` sign, for example `x++sin(x)` for fitting `[0]*x+[1]*sin(x)`
3896///
3897/// This function finds a pointer to the TF1 object with name `fname` and calls TH1::Fit(TF1 *, Option_t *, Option_t *,
3898/// Double_t, Double_t). See there for the fitting options and the details about fitting histograms
3899
3900TFitResultPtr TH1::Fit(const char *fname ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax)
3901{
3902 char *linear;
3903 linear= (char*)strstr(fname, "++");
3904 Int_t ndim=GetDimension();
3905 if (linear){
3906 if (ndim<2){
3907 TF1 f1(fname, fname, xxmin, xxmax);
3908 return Fit(&f1,option,goption,xxmin,xxmax);
3909 }
3910 else if (ndim<3){
3911 TF2 f2(fname, fname);
3912 return Fit(&f2,option,goption,xxmin,xxmax);
3913 }
3914 else{
3915 TF3 f3(fname, fname);
3916 return Fit(&f3,option,goption,xxmin,xxmax);
3917 }
3918 }
3919 else{
3920 TF1 * f1 = (TF1*)gROOT->GetFunction(fname);
3921 if (!f1) { Printf("Unknown function: %s",fname); return -1; }
3922 return Fit(f1,option,goption,xxmin,xxmax);
3923 }
3924}
3925
3926////////////////////////////////////////////////////////////////////////////////
3927/// Fit histogram with the function pointer f1.
3928///
3929/// \param[in] f1 pointer to the function object
3930/// \param[in] option string defining the fit options (see table below).
3931/// \param[in] goption specify a list of graphics options. See TH1::Draw for a complete list of these options.
3932/// \param[in] xxmin lower fitting range
3933/// \param[in] xxmax upper fitting range
3934/// \return A smart pointer to the TFitResult class
3935///
3936/// \anchor HFitOpt
3937/// ### Histogram Fitting Options
3938///
3939/// Here is the full list of fit options that can be given in the parameter `option`.
3940/// Several options can be used together by concatanating the strings without the need of any delimiters.
3941///
3942/// option | description
3943/// -------|------------
3944/// "L" | Uses a log likelihood method (default is chi-square method). To be used when the histogram represents counts.
3945/// "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.
3946/// "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.
3947/// "MULTI" | Uses Loglikelihood method based on multi-nomial distribution. In this case the function must be normalized and one fits only the function shape.
3948/// "W" | Fit using the chi-square method and ignoring the bin uncertainties and skip empty bins.
3949/// "WW" | Fit using the chi-square method and ignoring the bin uncertainties and include the empty bins.
3950/// "I" | Uses the integral of function in the bin instead of the default bin center value.
3951/// "F" | Uses the default minimizer (e.g. Minuit) when fitting a linear function (e.g. polN) instead of the linear fitter.
3952/// "U" | Uses a user specified objective function (e.g. user providedlikelihood function) defined using `TVirtualFitter::SetFCN`
3953/// "E" | Performs a better parameter errors estimation using the Minos technique for all fit parameters.
3954/// "M" | Uses the IMPROVE algorithm (available only in TMinuit). This algorithm attempts improve the found local minimum by searching for a better one.
3955/// "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`.
3956/// "Q" | Quiet mode (minimum printing)
3957/// "V" | Verbose mode (default is between Q and V)
3958/// "+" | 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.
3959/// "N" | Does not store the graphics function, does not draw the histogram with the function after fitting.
3960/// "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.
3961/// "R" | Fit using a fitting range specified in the function range with `TF1::SetRange`.
3962/// "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.
3963/// "C" | In case of linear fitting, do no calculate the chisquare (saves CPU time).
3964/// "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.
3965/// "WIDTH" | Scales the histogran bin content by the bin width (useful for variable bins histograms)
3966/// "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
3967/// "MULTITHREAD" | Forces usage of multi-thread execution whenever possible
3968///
3969/// The default fitting of an histogram (when no option is given) is perfomed as following:
3970/// - a chi-square fit (see below Chi-square Fits) computed using the bin histogram errors and excluding bins with zero errors (empty bins);
3971/// - the full range of the histogram is used;
3972/// - the default Minimizer with its default configuration is used (see below Minimizer Configuration) except for linear function;
3973/// - for linear functions (`polN`, `chenbyshev` or formula expressions combined using operator `++`) a linear minimization is used.
3974/// - only the status of the fit is returned;
3975/// - the fit is performed in Multithread whenever is enabled in ROOT;
3976/// - only the last fitted function is saved in the histogram;
3977/// - the histogram is drawn after fitting overalyed with the resulting fitting function
3978///
3979/// \anchor HFitMinimizer
3980/// ### Minimizer Configuration
3981///
3982/// The Fit is perfomed using the default Minimizer, defined in the `ROOT::Math::MinimizerOptions` class.
3983/// It is possible to change the default minimizer and its configuration parameters by calling these static functions before fitting (before calling `TH1::Fit`):
3984/// - `ROOT::Math::MinimizerOptions::SetDefaultMinimizer(minimizerName, minimizerAgorithm)` for changing the minmizer and/or the corresponding algorithm.
3985/// For example `ROOT::Math::MinimizerOptions::SetDefaultMinimizer("GSLMultiMin","BFGS");` will set the usage of the BFGS algorithm of the GSL multi-dimensional minimization
3986/// The current defaults are ("Minuit","Migrad").
3987/// See the documentation of the `ROOT::Math::MinimizerOptions` for the available minimizers in ROOT and their corresponding algorithms.
3988/// - `ROOT::Math::MinimizerOptions::SetDefaultTolerance` for setting a different tolerance value for the minimization.
3989/// - `ROOT::Math::MinimizerOptions::SetDefaultMaxFunctionCalls` for setting the maximum number of function calls.
3990/// - `ROOT::Math::MinimizerOptions::SetDefaultPrintLevel` for changing the minimizer print level from level=0 (minimal printing) to level=3 maximum printing
3991///
3992/// Other options are possible depending on the Minimizer used, see the corresponding documentation.
3993/// The default minimizer can be also set in the resource file in etc/system.rootrc. For example
3994///
3995/// ~~~ {.cpp}
3996/// Root.Fitter: Minuit2
3997/// ~~~
3998///
3999/// \anchor HFitChi2
4000/// ### Chi-square Fits
4001///
4002/// By default a chi-square (least-square) fit is performed on the histogram. The so-called modified least-square method
4003/// is used where the residual for each bin is computed using as error the observed value (the bin error) returned by `TH1::GetBinError`
4004///
4005/// \f[
4006/// Chi2 = \sum_{i}{ \left(\frac{y(i) - f(x(i) | p )}{e(i)} \right)^2 }
4007/// \f]
4008///
4009/// 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
4010/// an un-weighted histogram). Bins with zero errors are excluded from the fit. See also later the note on the treatment
4011/// of empty bins. When using option "I" the residual is computed not using the function value at the bin center, `f(x(i)|p)`,
4012/// but the integral of the function in the bin, Integral{ f(x|p)dx }, divided by the bin volume.
4013/// When using option `P` (Pearson chi2), the expected error computed as `e(i) = sqrt(f(x(i)|p))` is used.
4014/// In this case empty bins are considered in the fit.
4015/// Both chi-square methods should not be used when the bin content represent counts, especially in case of low bin statistics,
4016/// because they could return a biased result.
4017///
4018/// \anchor HFitNLL
4019/// ### Likelihood Fits
4020///
4021/// When using option "L" a likelihood fit is used instead of the default chi-square fit.
4022/// The likelihood is built assuming a Poisson probability density function for each bin.
4023/// The negative log-likelihood to be minimized is
4024///
4025/// \f[
4026/// NLL = - \sum_{i}{ \log {\mathrm P} ( y(i) | f(x(i) | p ) ) }
4027/// \f]
4028/// 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)`.
4029/// The exact likelihood used is the Poisson likelihood described in this paper:
4030/// S. Baker and R. D. Cousins, “Clarification of the use of chi-square and likelihood functions in fits to histograms,”
4031/// Nucl. Instrum. Meth. 221 (1984) 437.
4032///
4033/// \f[
4034/// NLL = \sum_{i}{( f(x(i) | p ) + y(i)\log(y(i)/ f(x(i) | p )) - y(i)) }
4035/// \f]
4036/// By using this formulation, `2*NLL` can be interpreted as the chi-square resulting from the fit.
4037///
4038/// This method should be always used when the bin content represents counts (i.e. errors are sqrt(N) ).
4039/// The likelihood method has the advantage of treating correctly bins with low statistics. In case of high
4040/// statistics/bin the distribution of the bin content becomes a normal distribution and the likelihood and the chi2 fit
4041/// give the same result.
4042///
4043/// The likelihood method, although a bit slower, it is therefore the recommended method,
4044/// when the histogram represent counts (Poisson statistics), where the chi-square methods may
4045/// give incorrect results, especially in case of low statistics.
4046/// In case of a weighted histogram, it is possible to perform also a likelihood fit by using the
4047/// option "WL". Note a weighted histogram is a histogram which has been filled with weights and it
4048/// has the information on the sum of the weight square for each bin ( TH1::Sumw2() has been called).
4049/// The bin error for a weighted histogram is the square root of the sum of the weight square.
4050///
4051/// \anchor HFitRes
4052/// ### Fit Result
4053///
4054/// The function returns a TFitResultPtr which can hold a pointer to a TFitResult object.
4055/// By default the TFitResultPtr contains only the status of the fit which is return by an
4056/// automatic conversion of the TFitResultPtr to an integer. One can write in this case directly:
4057///
4058/// ~~~ {.cpp}
4059/// Int_t fitStatus = h->Fit(myFunc);
4060/// ~~~
4061///
4062/// If the option "S" is instead used, TFitResultPtr behaves as a smart
4063/// pointer to the TFitResult object. This is useful for retrieving the full result information from the fit, such as the covariance matrix,
4064/// as shown in this example code:
4065///
4066/// ~~~ {.cpp}
4067/// TFitResultPtr r = h->Fit(myFunc,"S");
4068/// TMatrixDSym cov = r->GetCovarianceMatrix(); // to access the covariance matrix
4069/// Double_t chi2 = r->Chi2(); // to retrieve the fit chi2
4070/// Double_t par0 = r->Parameter(0); // retrieve the value for the parameter 0
4071/// Double_t err0 = r->ParError(0); // retrieve the error for the parameter 0
4072/// r->Print("V"); // print full information of fit including covariance matrix
4073/// r->Write(); // store the result in a file
4074/// ~~~
4075///
4076/// The fit parameters, error and chi-square (but not covariance matrix) can be retrieved also
4077/// directly from the fitted function that is passed to this call.
4078/// Given a pointer to an associated fitted function `myfunc`, one can retrieve the function/fit
4079/// parameters with calls such as:
4080///
4081/// ~~~ {.cpp}
4082/// Double_t chi2 = myfunc->GetChisquare();
4083/// Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter
4084/// Double_t err0 = myfunc->GetParError(0); //error on first parameter
4085/// ~~~
4086///
4087/// ##### Associated functions
4088///
4089/// One or more object ( can be added to the list
4090/// of functions (fFunctions) associated to each histogram.
4091/// When TH1::Fit is invoked, the fitted function is added to the histogram list of functions (fFunctions).
4092/// If the histogram is made persistent, the list of associated functions is also persistent.
4093/// Given a histogram h, one can retrieve an associated function with:
4094///
4095/// ~~~ {.cpp}
4096/// TF1 *myfunc = h->GetFunction("myfunc");
4097/// ~~~
4098/// or by quering directly the list obtained by calling `TH1::GetListOfFunctions`.
4099///
4100/// \anchor HFitStatus
4101/// ### Fit status
4102///
4103/// The status of the fit is obtained converting the TFitResultPtr to an integer
4104/// independently if the fit option "S" is used or not:
4105///
4106/// ~~~ {.cpp}
4107/// TFitResultPtr r = h->Fit(myFunc,opt);
4108/// Int_t fitStatus = r;
4109/// ~~~
4110///
4111/// - `status = 0` : the fit has been performed successfully (i.e no error occurred).
4112/// - `status < 0` : there is an error not connected with the minimization procedure, for example when a wrong function is used.
4113/// - `status > 0` : return status from Minimizer, depends on used Minimizer. For example for TMinuit and Minuit2 we have:
4114/// - `status = migradStatus + 10*minosStatus + 100*hesseStatus + 1000*improveStatus`.
4115/// 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
4116/// only in Minos but not in Migrad a fitStatus of 40 will be returned.
4117/// Minuit2 returns 0 in case of success and different values in migrad,minos or
4118/// hesse depending on the error. See in this case the documentation of
4119/// Minuit2Minimizer::Minimize for the migrad return status, Minuit2Minimizer::GetMinosError for the
4120/// minos return status and Minuit2Minimizer::Hesse for the hesse return status.
4121/// If other minimizers are used see their specific documentation for the status code returned.
4122/// For example in the case of Fumili, see TFumili::Minimize.
4123///
4124/// \anchor HFitRange
4125/// ### Fitting in a range
4126///
4127/// In order to fit in a sub-range of the histogram you have two options:
4128/// - pass to this function the lower (`xxmin`) and upper (`xxmax`) values for the fitting range;
4129/// - define a specific range in the fitted function and use the fitting option "R".
4130/// For example, if your histogram has a defined range between -4 and 4 and you want to fit a gaussian
4131/// only in the interval 1 to 3, you can do:
4132///
4133/// ~~~ {.cpp}
4134/// TF1 *f1 = new TF1("f1", "gaus", 1, 3);
4135/// histo->Fit("f1", "R");
4136/// ~~~
4137///
4138/// The fitting range is also limited by the histogram range defined using TAxis::SetRange
4139/// or TAxis::SetRangeUser. Therefore the fitting range is the smallest range between the
4140/// histogram one and the one defined by one of the two previous options described above.
4141///
4142/// \anchor HFitInitial
4143/// ### Setting initial conditions
4144///
4145/// Parameters must be initialized before invoking the Fit function.
4146/// The setting of the parameter initial values is automatic for the
4147/// predefined functions such as poln, expo, gaus, landau. One can however disable
4148/// this automatic computation by using the option "B".
4149/// Note that if a predefined function is defined with an argument,
4150/// eg, gaus(0), expo(1), you must specify the initial values for
4151/// the parameters.
4152/// You can specify boundary limits for some or all parameters via
4153///
4154/// ~~~ {.cpp}
4155/// f1->SetParLimits(p_number, parmin, parmax);
4156/// ~~~
4157///
4158/// if `parmin >= parmax`, the parameter is fixed
4159/// Note that you are not forced to fix the limits for all parameters.
4160/// For example, if you fit a function with 6 parameters, you can do:
4161///
4162/// ~~~ {.cpp}
4163/// func->SetParameters(0, 3.1, 1.e-6, -8, 0, 100);
4164/// func->SetParLimits(3, -10, -4);
4165/// func->FixParameter(4, 0);
4166/// func->SetParLimits(5, 1, 1);
4167/// ~~~
4168///
4169/// With this setup, parameters 0->2 can vary freely
4170/// Parameter 3 has boundaries [-10,-4] with initial value -8
4171/// Parameter 4 is fixed to 0
4172/// Parameter 5 is fixed to 100.
4173/// When the lower limit and upper limit are equal, the parameter is fixed.
4174/// However to fix a parameter to 0, one must call the FixParameter function.
4175///
4176/// \anchor HFitStatBox
4177/// ### Fit Statistics Box
4178///
4179/// The statistics box can display the result of the fit.
4180/// You can change the statistics box to display the fit parameters with
4181/// the TStyle::SetOptFit(mode) method. This mode has four digits.
4182/// mode = pcev (default = 0111)
4183///
4184/// v = 1; print name/values of parameters
4185/// e = 1; print errors (if e=1, v must be 1)
4186/// c = 1; print Chisquare/Number of degrees of freedom
4187/// p = 1; print Probability
4188///
4189/// For example: gStyle->SetOptFit(1011);
4190/// prints the fit probability, parameter names/values, and errors.
4191/// You can change the position of the statistics box with these lines
4192/// (where g is a pointer to the TGraph):
4193///
4194/// TPaveStats *st = (TPaveStats*)g->GetListOfFunctions()->FindObject("stats");
4195/// st->SetX1NDC(newx1); //new x start position
4196/// st->SetX2NDC(newx2); //new x end position
4197///
4198/// \anchor HFitExtra
4199/// ### Additional Notes on Fitting
4200///
4201/// #### Fitting a histogram of dimension N with a function of dimension N-1
4202///
4203/// It is possible to fit a TH2 with a TF1 or a TH3 with a TF2.
4204/// 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.
4205/// For correct error scaling, the obtained parameter error are corrected as in the case when the
4206/// option "W" is used.
4207///
4208/// #### User defined objective functions
4209///
4210/// By default when fitting a chi square function is used for fitting. When option "L" is used
4211/// a Poisson likelihood function is used. Using option "MULTI" a multinomial likelihood fit is used.
4212/// Thes functions are defined in the header Fit/Chi2Func.h or Fit/PoissonLikelihoodFCN and they
4213/// are implemented using the routines FitUtil::EvaluateChi2 or FitUtil::EvaluatePoissonLogL in
4214/// the file math/mathcore/src/FitUtil.cxx.
4215/// It is possible to specify a user defined fitting function, using option "U" and
4216/// calling the following functions:
4217///
4218/// ~~~ {.cpp}
4219/// TVirtualFitter::Fitter(myhist)->SetFCN(MyFittingFunction);
4220/// ~~~
4221///
4222/// where MyFittingFunction is of type:
4223///
4224/// ~~~ {.cpp}
4225/// extern void MyFittingFunction(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);
4226/// ~~~
4227///
4228/// #### Note on treatment of empty bins
4229///
4230/// Empty bins, which have the content equal to zero AND error equal to zero,
4231/// are excluded by default from the chi-square fit, but they are considered in the likelihood fit.
4232/// since they affect the likelihood if the function value in these bins is not negligible.
4233/// Note that if the histogram is having bins with zero content and non zero-errors they are considered as
4234/// any other bins in the fit. Instead bins with zero error and non-zero content are by default excluded in the chi-squared fit.
4235/// In general, one should not fit a histogram with non-empty bins and zero errors.
4236///
4237/// 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
4238/// fit). When using option "WW" the empty bins will be also considered in the chi-square fit with an error of 1.
4239/// Note that in this fitting case (option "W" or "WW") the resulting fitted parameter errors
4240/// are corrected by the obtained chi2 value using this scaling expression:
4241/// `errorp *= sqrt(chisquare/(ndf-1))` as it is done when fitting a TGraph with
4242/// no point errors.
4243///
4244/// #### Excluding points
4245///
4246/// You can use TF1::RejectPoint inside your fitting function to exclude some points
4247/// within a certain range from the fit. See the tutorial `fit/fitExclude.C`.
4248///
4249///
4250/// #### Warning when using the option "0"
4251///
4252/// When selecting the option "0", the fitted function is added to
4253/// the list of functions of the histogram, but it is not drawn when the histogram is drawn.
4254/// You can undo this behaviour resetting its corresponding bit in the TF1 object as following:
4255///
4256/// ~~~ {.cpp}
4257/// h.Fit("myFunction", "0"); // fit, store function but do not draw
4258/// h.Draw(); // function is not drawn
4259/// h.GetFunction("myFunction")->ResetBit(TF1::kNotDraw);
4260/// h.Draw(); // function is visible again
4261/// ~~~
4263
4265{
4266 // implementation of Fit method is in file hist/src/HFitImpl.cxx
4267 Foption_t fitOption;
4269
4270 // create range and minimizer options with default values
4271 ROOT::Fit::DataRange range(xxmin,xxmax);
4273
4274 // need to empty the buffer before
4275 // (t.b.d. do a ML unbinned fit with buffer data)
4276 if (fBuffer) BufferEmpty();
4277
4278 return ROOT::Fit::FitObject(this, f1 , fitOption , minOption, goption, range);
4279}
4280
4281////////////////////////////////////////////////////////////////////////////////
4282/// Display a panel with all histogram fit options.
4283///
4284/// See class TFitPanel for example
4285
4286void TH1::FitPanel()
4287{
4288 if (!gPad)
4289 gROOT->MakeDefCanvas();
4290
4291 if (!gPad) {
4292 Error("FitPanel", "Unable to create a default canvas");
4293 return;
4294 }
4295
4296
4297 // use plugin manager to create instance of TFitEditor
4298 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor");
4299 if (handler && handler->LoadPlugin() != -1) {
4300 if (handler->ExecPlugin(2, gPad, this) == 0)
4301 Error("FitPanel", "Unable to create the FitPanel");
4302 }
4303 else
4304 Error("FitPanel", "Unable to find the FitPanel plug-in");
4305}
4306
4307////////////////////////////////////////////////////////////////////////////////
4308/// Return a histogram containing the asymmetry of this histogram with h2,
4309/// where the asymmetry is defined as:
4310///
4311/// ~~~ {.cpp}
4312/// Asymmetry = (h1 - h2)/(h1 + h2) where h1 = this
4313/// ~~~
4314///
4315/// works for 1D, 2D, etc. histograms
4316/// c2 is an optional argument that gives a relative weight between the two
4317/// histograms, and dc2 is the error on this weight. This is useful, for example,
4318/// when forming an asymmetry between two histograms from 2 different data sets that
4319/// need to be normalized to each other in some way. The function calculates
4320/// the errors assuming Poisson statistics on h1 and h2 (that is, dh = sqrt(h)).
4321///
4322/// example: assuming 'h1' and 'h2' are already filled
4323///
4324/// ~~~ {.cpp}
4325/// h3 = h1->GetAsymmetry(h2)
4326/// ~~~
4327///
4328/// then 'h3' is created and filled with the asymmetry between 'h1' and 'h2';
4329/// h1 and h2 are left intact.
4330///
4331/// Note that it is the user's responsibility to manage the created histogram.
4332/// The name of the returned histogram will be `Asymmetry_nameOfh1-nameOfh2`
4333///
4334/// code proposed by Jason Seely (seely@mit.edu) and adapted by R.Brun
4335///
4336/// clone the histograms so top and bottom will have the
4337/// correct dimensions:
4338/// Sumw2 just makes sure the errors will be computed properly
4339/// when we form sums and ratios below.
4340
4342{
4343 TH1 *h1 = this;
4344 TString name = TString::Format("Asymmetry_%s-%s",h1->GetName(),h2->GetName() );
4345 TH1 *asym = (TH1*)Clone(name);
4346
4347 // set also the title
4348 TString title = TString::Format("(%s - %s)/(%s+%s)",h1->GetName(),h2->GetName(),h1->GetName(),h2->GetName() );
4349 asym->SetTitle(title);
4350
4351 asym->Sumw2();
4352 Bool_t addStatus = TH1::AddDirectoryStatus();
4354 TH1 *top = (TH1*)asym->Clone();
4355 TH1 *bottom = (TH1*)asym->Clone();
4356 TH1::AddDirectory(addStatus);
4357
4358 // form the top and bottom of the asymmetry, and then divide:
4359 top->Add(h1,h2,1,-c2);
4360 bottom->Add(h1,h2,1,c2);
4361 asym->Divide(top,bottom);
4362
4363 Int_t xmax = asym->GetNbinsX();
4364 Int_t ymax = asym->GetNbinsY();
4365 Int_t zmax = asym->GetNbinsZ();
4366
4367 if (h1->fBuffer) h1->BufferEmpty(1);
4368 if (h2->fBuffer) h2->BufferEmpty(1);
4369 if (bottom->fBuffer) bottom->BufferEmpty(1);
4370
4371 // now loop over bins to calculate the correct errors
4372 // the reason this error calculation looks complex is because of c2
4373 for(Int_t i=1; i<= xmax; i++){
4374 for(Int_t j=1; j<= ymax; j++){
4375 for(Int_t k=1; k<= zmax; k++){
4376 Int_t bin = GetBin(i, j, k);
4377 // here some bin contents are written into variables to make the error
4378 // calculation a little more legible:
4380 Double_t b = h2->RetrieveBinContent(bin);
4381 Double_t bot = bottom->RetrieveBinContent(bin);
4382
4383 // make sure there are some events, if not, then the errors are set = 0
4384 // automatically.
4385 //if(bot < 1){} was changed to the next line from recommendation of Jason Seely (28 Nov 2005)
4386 if(bot < 1e-6){}
4387 else{
4388 // computation of errors by Christos Leonidopoulos
4389 Double_t dasq = h1->GetBinErrorSqUnchecked(bin);
4390 Double_t dbsq = h2->GetBinErrorSqUnchecked(bin);
4391 Double_t error = 2*TMath::Sqrt(a*a*c2*c2*dbsq + c2*c2*b*b*dasq+a*a*b*b*dc2*dc2)/(bot*bot);
4392 asym->SetBinError(i,j,k,error);
4393 }
4394 }
4395 }
4396 }
4397 delete top;
4398 delete bottom;
4399
4400 return asym;
4401}
4402
4403////////////////////////////////////////////////////////////////////////////////
4404/// Static function
4405/// return the default buffer size for automatic histograms
4406/// the parameter fgBufferSize may be changed via SetDefaultBufferSize
4407
4409{
4410 return fgBufferSize;
4411}
4412
4413////////////////////////////////////////////////////////////////////////////////
4414/// Return kTRUE if TH1::Sumw2 must be called when creating new histograms.
4415/// see TH1::SetDefaultSumw2.
4416
4418{
4419 return fgDefaultSumw2;
4420}
4421
4422////////////////////////////////////////////////////////////////////////////////
4423/// Return the current number of entries.
4424
4426{
4427 if (fBuffer) {
4428 Int_t nentries = (Int_t) fBuffer[0];
4429 if (nentries > 0) return nentries;
4430 }
4431
4432 return fEntries;
4433}
4434
4435////////////////////////////////////////////////////////////////////////////////
4436/// Number of effective entries of the histogram.
4437///
4438/// \f[
4439/// neff = \frac{(\sum Weights )^2}{(\sum Weight^2 )}
4440/// \f]
4441///
4442/// In case of an unweighted histogram this number is equivalent to the
4443/// number of entries of the histogram.
4444/// For a weighted histogram, this number corresponds to the hypothetical number of unweighted entries
4445/// a histogram would need to have the same statistical power as this weighted histogram.
4446/// Note: The underflow/overflow are included if one has set the TH1::StatOverFlows flag
4447/// and if the statistics has been computed at filling time.
4448/// If a range is set in the histogram the number is computed from the given range.
4449
4451{
4452 Stat_t s[kNstat];
4453 this->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
4454 return (s[1] ? s[0]*s[0]/s[1] : TMath::Abs(s[0]) );
4455}
4456
4457////////////////////////////////////////////////////////////////////////////////
4458/// Set highlight (enable/disable) mode for the histogram
4459/// by default highlight mode is disable
4460
4461void TH1::SetHighlight(Bool_t set)
4462{
4463 if (IsHighlight() == set)
4464 return;
4465 if (fDimension > 2) {
4466 Info("SetHighlight", "Supported only 1-D or 2-D histograms");
4467 return;
4468 }
4469
4470 SetBit(kIsHighlight, set);
4471
4472 if (fPainter)
4474}
4475
4476////////////////////////////////////////////////////////////////////////////////
4477/// Redefines TObject::GetObjectInfo.
4478/// Displays the histogram info (bin number, contents, integral up to bin
4479/// corresponding to cursor position px,py
4480
4481char *TH1::GetObjectInfo(Int_t px, Int_t py) const
4482{
4483 return ((TH1*)this)->GetPainter()->GetObjectInfo(px,py);
4484}
4485
4486////////////////////////////////////////////////////////////////////////////////
4487/// Return pointer to painter.
4488/// If painter does not exist, it is created
4489
4491{
4492 if (!fPainter) {
4493 TString opt = option;
4494 opt.ToLower();
4495 if (opt.Contains("gl") || gStyle->GetCanvasPreferGL()) {
4496 //try to create TGLHistPainter
4497 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TGLHistPainter");
4498
4499 if (handler && handler->LoadPlugin() != -1)
4500 fPainter = reinterpret_cast<TVirtualHistPainter *>(handler->ExecPlugin(1, this));
4501 }
4502 }
4503
4505
4506 return fPainter;
4507}
4508
4509////////////////////////////////////////////////////////////////////////////////
4510/// Compute Quantiles for this histogram
4511/// Quantile x_q of a probability distribution Function F is defined as
4512///
4513/// ~~~ {.cpp}
4514/// F(x_q) = q with 0 <= q <= 1.
4515/// ~~~
4516///
4517/// For instance the median x_0.5 of a distribution is defined as that value
4518/// of the random variable for which the distribution function equals 0.5:
4519///
4520/// ~~~ {.cpp}
4521/// F(x_0.5) = Probability(x < x_0.5) = 0.5
4522/// ~~~
4523///
4524/// code from Eddy Offermann, Renaissance
4525///
4526/// \param[in] nprobSum maximum size of array q and size of array probSum (if given)
4527/// \param[in] probSum array of positions where quantiles will be computed.
4528/// - if probSum is null, probSum will be computed internally and will
4529/// have a size = number of bins + 1 in h. it will correspond to the
4530/// quantiles calculated at the lowest edge of the histogram (quantile=0) and
4531/// all the upper edges of the bins.
4532/// - if probSum is not null, it is assumed to contain at least nprobSum values.
4533/// \param[out] q array q filled with nq quantiles
4534/// \return value nq (<=nprobSum) with the number of quantiles computed
4535///
4536/// Note that the Integral of the histogram is automatically recomputed
4537/// if the number of entries is different of the number of entries when
4538/// the integral was computed last time. In case you do not use the Fill
4539/// functions to fill your histogram, but SetBinContent, you must call
4540/// TH1::ComputeIntegral before calling this function.
4541///
4542/// Getting quantiles q from two histograms and storing results in a TGraph,
4543/// a so-called QQ-plot
4544///
4545/// ~~~ {.cpp}
4546/// TGraph *gr = new TGraph(nprob);
4547/// h1->GetQuantiles(nprob,gr->GetX());
4548/// h2->GetQuantiles(nprob,gr->GetY());
4549/// gr->Draw("alp");
4550/// ~~~
4551///
4552/// Example:
4553///
4554/// ~~~ {.cpp}
4555/// void quantiles() {
4556/// // demo for quantiles
4557/// const Int_t nq = 20;
4558/// TH1F *h = new TH1F("h","demo quantiles",100,-3,3);
4559/// h->FillRandom("gaus",5000);
4560///
4561/// Double_t xq[nq]; // position where to compute the quantiles in [0,1]
4562/// Double_t yq[nq]; // array to contain the quantiles
4563/// for (Int_t i=0;i<nq;i++) xq[i] = Float_t(i+1)/nq;
4564/// h->GetQuantiles(nq,yq,xq);
4565///
4566/// //show the original histogram in the top pad
4567/// TCanvas *c1 = new TCanvas("c1","demo quantiles",10,10,700,900);
4568/// c1->Divide(1,2);
4569/// c1->cd(1);
4570/// h->Draw();
4571///
4572/// // show the quantiles in the bottom pad
4573/// c1->cd(2);
4574/// gPad->SetGrid();
4575/// TGraph *gr = new TGraph(nq,xq,yq);
4576/// gr->SetMarkerStyle(21);
4577/// gr->Draw("alp");
4578/// }
4579/// ~~~
4580
4581Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum)
4582{
4583 if (GetDimension() > 1) {
4584 Error("GetQuantiles","Only available for 1-d histograms");
4585 return 0;
4586 }
4587
4588 const Int_t nbins = GetXaxis()->GetNbins();
4589 if (!fIntegral) ComputeIntegral();
4590 if (fIntegral[nbins+1] != fEntries) ComputeIntegral();
4591
4592 Int_t i, ibin;
4593 Double_t *prob = (Double_t*)probSum;
4594 Int_t nq = nprobSum;
4595 if (probSum == nullptr) {
4596 nq = nbins+1;
4597 prob = new Double_t[nq];
4598 prob[0] = 0;
4599 for (i=1;i<nq;i++) {
4600 prob[i] = fIntegral[i]/fIntegral[nbins];
4601 }
4602 }
4603
4604 for (i = 0; i < nq; i++) {
4605 ibin = TMath::BinarySearch(nbins,fIntegral,prob[i]);
4606 while (ibin < nbins-1 && fIntegral[ibin+1] == prob[i]) {
4607 if (fIntegral[ibin+2] == prob[i]) ibin++;
4608 else break;
4609 }
4610 q[i] = GetBinLowEdge(ibin+1);
4611 const Double_t dint = fIntegral[ibin+1]-fIntegral[ibin];
4612 if (dint > 0) q[i] += GetBinWidth(ibin+1)*(prob[i]-fIntegral[ibin])/dint;
4613 }
4614
4615 if (!probSum) delete [] prob;
4616 return nq;
4617}
4618
4619////////////////////////////////////////////////////////////////////////////////
4620/// Decode string choptin and fill fitOption structure.
4621
4622Int_t TH1::FitOptionsMake(Option_t *choptin, Foption_t &fitOption)
4623{
4625 return 1;
4626}
4627
4628////////////////////////////////////////////////////////////////////////////////
4629/// Compute Initial values of parameters for a gaussian.
4630
4631void H1InitGaus()
4632{
4633 Double_t allcha, sumx, sumx2, x, val, stddev, mean;
4634 Int_t bin;
4635 const Double_t sqrtpi = 2.506628;
4636
4637 // - Compute mean value and StdDev of the histogram in the given range
4639 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4640 Int_t hxfirst = hFitter->GetXfirst();
4641 Int_t hxlast = hFitter->GetXlast();
4642 Double_t valmax = curHist->GetBinContent(hxfirst);
4643 Double_t binwidx = curHist->GetBinWidth(hxfirst);
4644 allcha = sumx = sumx2 = 0;
4645 for (bin=hxfirst;bin<=hxlast;bin++) {
4646 x = curHist->GetBinCenter(bin);
4647 val = TMath::Abs(curHist->GetBinContent(bin));
4648 if (val > valmax) valmax = val;
4649 sumx += val*x;
4650 sumx2 += val*x*x;
4651 allcha += val;
4652 }
4653 if (allcha == 0) return;
4654 mean = sumx/allcha;
4655 stddev = sumx2/allcha - mean*mean;
4656 if (stddev > 0) stddev = TMath::Sqrt(stddev);
4657 else stddev = 0;
4658 if (stddev == 0) stddev = binwidx*(hxlast-hxfirst+1)/4;
4659 //if the distribution is really gaussian, the best approximation
4660 //is binwidx*allcha/(sqrtpi*stddev)
4661 //However, in case of non-gaussian tails, this underestimates
4662 //the normalisation constant. In this case the maximum value
4663 //is a better approximation.
4664 //We take the average of both quantities
4665 Double_t constant = 0.5*(valmax+binwidx*allcha/(sqrtpi*stddev));
4666
4667 //In case the mean value is outside the histo limits and
4668 //the StdDev is bigger than the range, we take
4669 // mean = center of bins
4670 // stddev = half range
4671 Double_t xmin = curHist->GetXaxis()->GetXmin();
4672 Double_t xmax = curHist->GetXaxis()->GetXmax();
4673 if ((mean < xmin || mean > xmax) && stddev > (xmax-xmin)) {
4674 mean = 0.5*(xmax+xmin);
4675 stddev = 0.5*(xmax-xmin);
4676 }
4677 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4678 f1->SetParameter(0,constant);
4679 f1->SetParameter(1,mean);
4680 f1->SetParameter(2,stddev);
4681 f1->SetParLimits(2,0,10*stddev);
4682}
4683
4684////////////////////////////////////////////////////////////////////////////////
4685/// Compute Initial values of parameters for an exponential.
4686
4687void H1InitExpo()
4688{
4689 Double_t constant, slope;
4690 Int_t ifail;
4692 Int_t hxfirst = hFitter->GetXfirst();
4693 Int_t hxlast = hFitter->GetXlast();
4694 Int_t nchanx = hxlast - hxfirst + 1;
4695
4696 H1LeastSquareLinearFit(-nchanx, constant, slope, ifail);
4697
4698 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4699 f1->SetParameter(0,constant);
4700 f1->SetParameter(1,slope);
4701
4702}
4703
4704////////////////////////////////////////////////////////////////////////////////
4705/// Compute Initial values of parameters for a polynom.
4706
4707void H1InitPolynom()
4708{
4709 Double_t fitpar[25];
4710
4712 TF1 *f1 = (TF1*)hFitter->GetUserFunc();
4713 Int_t hxfirst = hFitter->GetXfirst();
4714 Int_t hxlast = hFitter->GetXlast();
4715 Int_t nchanx = hxlast - hxfirst + 1;
4716 Int_t npar = f1->GetNpar();
4717
4718 if (nchanx <=1 || npar == 1) {
4719 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4720 fitpar[0] = curHist->GetSumOfWeights()/Double_t(nchanx);
4721 } else {
4722 H1LeastSquareFit( nchanx, npar, fitpar);
4723 }
4724 for (Int_t i=0;i<npar;i++) f1->SetParameter(i, fitpar[i]);
4725}
4726
4727////////////////////////////////////////////////////////////////////////////////
4728/// Least squares lpolynomial fitting without weights.
4729///
4730/// \param[in] n number of points to fit
4731/// \param[in] m number of parameters
4732/// \param[in] a array of parameters
4733///
4734/// based on CERNLIB routine LSQ: Translated to C++ by Rene Brun
4735/// (E.Keil. revised by B.Schorr, 23.10.1981.)
4736
4738{
4739 const Double_t zero = 0.;
4740 const Double_t one = 1.;
4741 const Int_t idim = 20;
4742
4743 Double_t b[400] /* was [20][20] */;
4744 Int_t i, k, l, ifail;
4745 Double_t power;
4746 Double_t da[20], xk, yk;
4747
4748 if (m <= 2) {
4749 H1LeastSquareLinearFit(n, a[0], a[1], ifail);
4750 return;
4751 }
4752 if (m > idim || m > n) return;
4753 b[0] = Double_t(n);
4754 da[0] = zero;
4755 for (l = 2; l <= m; ++l) {
4756 b[l-1] = zero;
4757 b[m + l*20 - 21] = zero;
4758 da[l-1] = zero;
4759 }
4761 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4762 Int_t hxfirst = hFitter->GetXfirst();
4763 Int_t hxlast = hFitter->GetXlast();
4764 for (k = hxfirst; k <= hxlast; ++k) {
4765 xk = curHist->GetBinCenter(k);
4766 yk = curHist->GetBinContent(k);
4767 power = one;
4768 da[0] += yk;
4769 for (l = 2; l <= m; ++l) {
4770 power *= xk;
4771 b[l-1] += power;
4772 da[l-1] += power*yk;
4773 }
4774 for (l = 2; l <= m; ++l) {
4775 power *= xk;
4776 b[m + l*20 - 21] += power;
4777 }
4778 }
4779 for (i = 3; i <= m; ++i) {
4780 for (k = i; k <= m; ++k) {
4781 b[k - 1 + (i-1)*20 - 21] = b[k + (i-2)*20 - 21];
4782 }
4783 }
4784 H1LeastSquareSeqnd(m, b, idim, ifail, 1, da);
4785
4786 for (i=0; i<m; ++i) a[i] = da[i];
4787
4788}
4789
4790////////////////////////////////////////////////////////////////////////////////
4791/// Least square linear fit without weights.
4792///
4793/// extracted from CERNLIB LLSQ: Translated to C++ by Rene Brun
4794/// (added to LSQ by B. Schorr, 15.02.1982.)
4795
4796void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail)
4797{
4798 Double_t xbar, ybar, x2bar;
4799 Int_t i, n;
4800 Double_t xybar;
4801 Double_t fn, xk, yk;
4802 Double_t det;
4803
4804 n = TMath::Abs(ndata);
4805 ifail = -2;
4806 xbar = ybar = x2bar = xybar = 0;
4808 TH1 *curHist = (TH1*)hFitter->GetObjectFit();
4809 Int_t hxfirst = hFitter->GetXfirst();
4810 Int_t hxlast = hFitter->GetXlast();
4811 for (i = hxfirst; i <= hxlast; ++i) {
4812 xk = curHist->GetBinCenter(i);
4813 yk = curHist->GetBinContent(i);
4814 if (ndata < 0) {
4815 if (yk <= 0) yk = 1e-9;
4816 yk = TMath::Log(yk);
4817 }
4818 xbar += xk;
4819 ybar += yk;
4820 x2bar += xk*xk;
4821 xybar += xk*yk;
4822 }
4823 fn = Double_t(n);
4824 det = fn*x2bar - xbar*xbar;
4825 ifail = -1;
4826 if (det <= 0) {
4827 a0 = ybar/fn;
4828 a1 = 0;
4829 return;
4830 }
4831 ifail = 0;
4832 a0 = (x2bar*ybar - xbar*xybar) / det;
4833 a1 = (fn*xybar - xbar*ybar) / det;
4834
4835}
4836
4837////////////////////////////////////////////////////////////////////////////////
4838/// Extracted from CERN Program library routine DSEQN.
4839///
4840/// Translated to C++ by Rene Brun
4841
4842void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b)
4843{
4844 Int_t a_dim1, a_offset, b_dim1, b_offset;
4845 Int_t nmjp1, i, j, l;
4846 Int_t im1, jp1, nm1, nmi;
4847 Double_t s1, s21, s22;
4848 const Double_t one = 1.;
4849
4850 /* Parameter adjustments */
4851 b_dim1 = idim;
4852 b_offset = b_dim1 + 1;
4853 b -= b_offset;
4854 a_dim1 = idim;
4855 a_offset = a_dim1 + 1;
4856 a -= a_offset;
4857
4858 if (idim < n) return;
4859
4860 ifail = 0;
4861 for (j = 1; j <= n; ++j) {
4862 if (a[j + j*a_dim1] <= 0) { ifail = -1; return; }
4863 a[j + j*a_dim1] = one / a[j + j*a_dim1];
4864 if (j == n) continue;
4865 jp1 = j + 1;
4866 for (l = jp1; l <= n; ++l) {
4867 a[j + l*a_dim1] = a[j + j*a_dim1] * a[l + j*a_dim1];
4868 s1 = -a[l + (j+1)*a_dim1];
4869 for (i = 1; i <= j; ++i) { s1 = a[l + i*a_dim1] * a[i + (j+1)*a_dim1] + s1; }
4870 a[l + (j+1)*a_dim1] = -s1;
4871 }
4872 }
4873 if (k <= 0) return;
4874
4875 for (l = 1; l <= k; ++l) {
4876 b[l*b_dim1 + 1] = a[a_dim1 + 1]*b[l*b_dim1 + 1];
4877 }
4878 if (n == 1) return;
4879 for (l = 1; l <= k; ++l) {
4880 for (i = 2; i <= n; ++i) {
4881 im1 = i - 1;
4882 s21 = -b[i + l*b_dim1];
4883 for (j = 1; j <= im1; ++j) {
4884 s21 = a[i + j*a_dim1]*b[j + l*b_dim1] + s21;
4885 }
4886 b[i + l*b_dim1] = -a[i + i*a_dim1]*s21;
4887 }
4888 nm1 = n - 1;
4889 for (i = 1; i <= nm1; ++i) {
4890 nmi = n - i;
4891 s22 = -b[nmi + l*b_dim1];
4892 for (j = 1; j <= i; ++j) {
4893 nmjp1 = n - j + 1;
4894 s22 = a[nmi + nmjp1*a_dim1]*b[nmjp1 + l*b_dim1] + s22;
4895 }
4896 b[nmi + l*b_dim1] = -s22;
4897 }
4898 }
4899}
4900
4901////////////////////////////////////////////////////////////////////////////////
4902/// Return Global bin number corresponding to binx,y,z.
4903///
4904/// 2-D and 3-D histograms are represented with a one dimensional
4905/// structure.
4906/// This has the advantage that all existing functions, such as
4907/// GetBinContent, GetBinError, GetBinFunction work for all dimensions.
4908///
4909/// In case of a TH1x, returns binx directly.
4910/// see TH1::GetBinXYZ for the inverse transformation.
4911///
4912/// Convention for numbering bins
4913///
4914/// For all histogram types: nbins, xlow, xup
4915///
4916/// - bin = 0; underflow bin
4917/// - bin = 1; first bin with low-edge xlow INCLUDED
4918/// - bin = nbins; last bin with upper-edge xup EXCLUDED
4919/// - bin = nbins+1; overflow bin
4920///
4921/// In case of 2-D or 3-D histograms, a "global bin" number is defined.
4922/// For example, assuming a 3-D histogram with binx,biny,binz, the function
4923///
4924/// ~~~ {.cpp}
4925/// Int_t bin = h->GetBin(binx,biny,binz);
4926/// ~~~
4927///
4928/// returns a global/linearized bin number. This global bin is useful
4929/// to access the bin information independently of the dimension.
4930
4931Int_t TH1::GetBin(Int_t binx, Int_t, Int_t) const
4932{
4933 Int_t ofx = fXaxis.GetNbins() + 1; // overflow bin
4934 if (binx < 0) binx = 0;
4935 if (binx > ofx) binx = ofx;
4936
4937 return binx;
4938}
4939
4940////////////////////////////////////////////////////////////////////////////////
4941/// Return binx, biny, binz corresponding to the global bin number globalbin
4942/// see TH1::GetBin function above
4943
4944void TH1::GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const
4945{
4946 Int_t nx = fXaxis.GetNbins()+2;
4947 Int_t ny = fYaxis.GetNbins()+2;
4948
4949 if (GetDimension() == 1) {
4950 binx = binglobal%nx;
4951 biny = 0;
4952 binz = 0;
4953 return;
4954 }
4955 if (GetDimension() == 2) {
4956 binx = binglobal%nx;
4957 biny = ((binglobal-binx)/nx)%ny;
4958 binz = 0;
4959 return;
4960 }
4961 if (GetDimension() == 3) {
4962 binx = binglobal%nx;
4963 biny = ((binglobal-binx)/nx)%ny;
4964 binz = ((binglobal-binx)/nx -biny)/ny;
4965 }
4966}
4967
4968////////////////////////////////////////////////////////////////////////////////
4969/// Return a random number distributed according the histogram bin contents.
4970/// This function checks if the bins integral exists. If not, the integral
4971/// is evaluated, normalized to one.
4972///
4973/// @param rng (optional) Random number generator pointer used (default is gRandom)
4974///
4975/// The integral is automatically recomputed if the number of entries
4976/// is not the same then when the integral was computed.
4977/// NB Only valid for 1-d histograms. Use GetRandom2 or 3 otherwise.
4978/// If the histogram has a bin with negative content a NaN is returned
4979
4980Double_t TH1::GetRandom(TRandom * rng) const
4981{
4982 if (fDimension > 1) {
4983 Error("GetRandom","Function only valid for 1-d histograms");
4984 return 0;
4985 }
4986 Int_t nbinsx = GetNbinsX();
4987 Double_t integral = 0;
4988 // compute integral checking that all bins have positive content (see ROOT-5894)
4989 if (fIntegral) {
4990 if (fIntegral[nbinsx+1] != fEntries) integral = ((TH1*)this)->ComputeIntegral(true);
4991 else integral = fIntegral[nbinsx];
4992 } else {
4993 integral = ((TH1*)this)->ComputeIntegral(true);
4994 }
4995 if (integral == 0) return 0;
4996 // return a NaN in case some bins have negative content
4997 if (integral == TMath::QuietNaN() ) return TMath::QuietNaN();
4998
4999 Double_t r1 = (rng) ? rng->Rndm() : gRandom->Rndm();
5000 Int_t ibin = TMath::BinarySearch(nbinsx,fIntegral,r1);
5001 Double_t x = GetBinLowEdge(ibin+1);
5002 if (r1 > fIntegral[ibin]) x +=
5003 GetBinWidth(ibin+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]);
5004 return x;
5005}
5006
5007////////////////////////////////////////////////////////////////////////////////
5008/// Return content of bin number bin.
5009///
5010/// Implemented in TH1C,S,F,D
5011///
5012/// Convention for numbering bins
5013///
5014/// For all histogram types: nbins, xlow, xup
5015///
5016/// - bin = 0; underflow bin
5017/// - bin = 1; first bin with low-edge xlow INCLUDED
5018/// - bin = nbins; last bin with upper-edge xup EXCLUDED
5019/// - bin = nbins+1; overflow bin
5020///
5021/// In case of 2-D or 3-D histograms, a "global bin" number is defined.
5022/// For example, assuming a 3-D histogram with binx,biny,binz, the function
5023///
5024/// ~~~ {.cpp}
5025/// Int_t bin = h->GetBin(binx,biny,binz);
5026/// ~~~
5027///
5028/// returns a global/linearized bin number. This global bin is useful
5029/// to access the bin information independently of the dimension.
5030
5032{
5033 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
5034 if (bin < 0) bin = 0;
5035 if (bin >= fNcells) bin = fNcells-1;
5036
5037 return RetrieveBinContent(bin);
5038}
5039
5040////////////////////////////////////////////////////////////////////////////////
5041/// Compute first binx in the range [firstx,lastx] for which
5042/// diff = abs(bin_content-c) <= maxdiff
5043///
5044/// In case several bins in the specified range with diff=0 are found
5045/// the first bin found is returned in binx.
5046/// In case several bins in the specified range satisfy diff <=maxdiff
5047/// the bin with the smallest difference is returned in binx.
5048/// In all cases the function returns the smallest difference.
5049///
5050/// NOTE1: if firstx <= 0, firstx is set to bin 1
5051/// if (lastx < firstx then firstx is set to the number of bins
5052/// ie if firstx=0 and lastx=0 (default) the search is on all bins.
5053///
5054/// NOTE2: if maxdiff=0 (default), the first bin with content=c is returned.
5055
5056Double_t TH1::GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx, Int_t lastx,Double_t maxdiff) const
5057{
5058 if (fDimension > 1) {
5059 binx = 0;
5060 Error("GetBinWithContent","function is only valid for 1-D histograms");
5061 return 0;
5062 }
5063
5064 if (fBuffer) ((TH1*)this)->BufferEmpty();
5065
5066 if (firstx <= 0) firstx = 1;
5067 if (lastx < firstx) lastx = fXaxis.GetNbins();
5068 Int_t binminx = 0;
5069 Double_t diff, curmax = 1.e240;
5070 for (Int_t i=firstx;i<=lastx;i++) {
5071 diff = TMath::Abs(RetrieveBinContent(i)-c);
5072 if (diff <= 0) {binx = i; return diff;}
5073 if (diff < curmax && diff <= maxdiff) {curmax = diff, binminx=i;}
5074 }
5075 binx = binminx;
5076 return curmax;
5077}
5078
5079////////////////////////////////////////////////////////////////////////////////
5080/// Given a point x, approximates the value via linear interpolation
5081/// based on the two nearest bin centers
5082///
5083/// Andy Mastbaum 10/21/08
5084
5086{
5087 if (fBuffer) ((TH1*)this)->BufferEmpty();
5088
5089 Int_t xbin = fXaxis.FindFixBin(x);
5090 Double_t x0,x1,y0,y1;
5091
5092 if(x<=GetBinCenter(1)) {
5093 return RetrieveBinContent(1);
5094 } else if(x>=GetBinCenter(GetNbinsX())) {
5095 return RetrieveBinContent(GetNbinsX());
5096 } else {
5097 if(x<=GetBinCenter(xbin)) {
5098 y0 = RetrieveBinContent(xbin-1);
5099 x0 = GetBinCenter(xbin-1);
5100 y1 = RetrieveBinContent(xbin);
5101 x1 = GetBinCenter(xbin);
5102 } else {
5103 y0 = RetrieveBinContent(xbin);
5104 x0 = GetBinCenter(xbin);
5105 y1 = RetrieveBinContent(xbin+1);
5106 x1 = GetBinCenter(xbin+1);
5107 }
5108 return y0 + (x-x0)*((y1-y0)/(x1-x0));
5109 }
5110}
5111
5112////////////////////////////////////////////////////////////////////////////////
5113/// 2d Interpolation. Not yet implemented.
5114
5116{
5117 Error("Interpolate","This function must be called with 1 argument for a TH1");
5118 return 0;
5119}
5120
5121////////////////////////////////////////////////////////////////////////////////
5122/// 3d Interpolation. Not yet implemented.
5123
5125{
5126 Error("Interpolate","This function must be called with 1 argument for a TH1");
5127 return 0;
5128}
5129
5130///////////////////////////////////////////////////////////////////////////////
5131/// Check if a histogram is empty
5132/// (this is a protected method used mainly by TH1Merger )
5133
5134Bool_t TH1::IsEmpty() const
5135{
5136 // if fTsumw or fentries are not zero histogram is not empty
5137 // need to use GetEntries() instead of fEntries in case of bugger histograms
5138 // so we will flash the buffer
5139 if (fTsumw != 0) return kFALSE;
5140 if (GetEntries() != 0) return kFALSE;
5141 // case fTSumw == 0 amd entries are also zero
5142 // this should not really happening, but if one sets content by hand
5143 // it can happen. a call to ResetStats() should be done in such cases
5144 double sumw = 0;
5145 for (int i = 0; i< GetNcells(); ++i) sumw += RetrieveBinContent(i);
5146 return (sumw != 0) ? kFALSE : kTRUE;
5147}
5148
5149////////////////////////////////////////////////////////////////////////////////
5150/// Return true if the bin is overflow.
5151
5152Bool_t TH1::IsBinOverflow(Int_t bin, Int_t iaxis) const
5153{
5154 Int_t binx, biny, binz;
5155 GetBinXYZ(bin, binx, biny, binz);
5156
5157 if (iaxis == 0) {
5158 if ( fDimension == 1 )
5159 return binx >= GetNbinsX() + 1;
5160 if ( fDimension == 2 )
5161 return (binx >= GetNbinsX() + 1) ||
5162 (biny >= GetNbinsY() + 1);
5163 if ( fDimension == 3 )
5164 return (binx >= GetNbinsX() + 1) ||
5165 (biny >= GetNbinsY() + 1) ||
5166 (binz >= GetNbinsZ() + 1);
5167 return kFALSE;
5168 }
5169 if (iaxis == 1)
5170 return binx >= GetNbinsX() + 1;
5171 if (iaxis == 2)
5172 return biny >= GetNbinsY() + 1;
5173 if (iaxis == 3)
5174 return binz >= GetNbinsZ() + 1;
5175
5176 Error("IsBinOverflow","Invalid axis value");
5177 return kFALSE;
5178}
5179
5180////////////////////////////////////////////////////////////////////////////////
5181/// Return true if the bin is underflow.
5182/// If iaxis = 0 make OR with all axes otherwise check only for the given axis
5183
5184Bool_t TH1::IsBinUnderflow(Int_t bin, Int_t iaxis) const
5185{
5186 Int_t binx, biny, binz;
5187 GetBinXYZ(bin, binx, biny, binz);
5188
5189 if (iaxis == 0) {
5190 if ( fDimension == 1 )
5191 return (binx <= 0);
5192 else if ( fDimension == 2 )
5193 return (binx <= 0 || biny <= 0);
5194 else if ( fDimension == 3 )
5195 return (binx <= 0 || biny <= 0 || binz <= 0);
5196 else
5197 return kFALSE;
5198 }
5199 if (iaxis == 1)
5200 return (binx <= 0);
5201 if (iaxis == 2)
5202 return (biny <= 0);
5203 if (iaxis == 3)
5204 return (binz <= 0);
5205
5206 Error("IsBinUnderflow","Invalid axis value");
5207 return kFALSE;
5208}
5209
5210////////////////////////////////////////////////////////////////////////////////
5211/// Reduce the number of bins for the axis passed in the option to the number of bins having a label.
5212/// The method will remove only the extra bins existing after the last "labeled" bin.
5213/// Note that if there are "un-labeled" bins present between "labeled" bins they will not be removed
5214
5216{
5217 Int_t iaxis = AxisChoice(ax);
5218 TAxis *axis = nullptr;
5219 if (iaxis == 1) axis = GetXaxis();
5220 if (iaxis == 2) axis = GetYaxis();
5221 if (iaxis == 3) axis = GetZaxis();
5222 if (!axis) {
5223 Error("LabelsDeflate","Invalid axis option %s",ax);
5224 return;
5225 }
5226 if (!axis->GetLabels()) return;
5227
5228 // find bin with last labels
5229 // bin number is object ID in list of labels
5230 // therefore max bin number is number of bins of the deflated histograms
5231 TIter next(axis->GetLabels());
5232 TObject *obj;
5233 Int_t nbins = 0;
5234 while ((obj = next())) {
5235 Int_t ibin = obj->GetUniqueID();
5236 if (ibin > nbins) nbins = ibin;
5237 }
5238 if (nbins < 1) nbins = 1;
5239
5240 // Do nothing in case it was the last bin
5241 if (nbins==axis->GetNbins()) return;
5242
5243 TH1 *hold = (TH1*)IsA()->New();
5244 R__ASSERT(hold);
5245 hold->SetDirectory(nullptr);
5246 Copy(*hold);
5247
5248 Bool_t timedisp = axis->GetTimeDisplay();
5249 Double_t xmin = axis->GetXmin();
5250 Double_t xmax = axis->GetBinUpEdge(nbins);
5251 if (xmax <= xmin) xmax = xmin +nbins;
5252 axis->SetRange(0,0);
5253 axis->Set(nbins,xmin,xmax);
5254 SetBinsLength(-1); // reset the number of cells
5255 Int_t errors = fSumw2.fN;
5256 if (errors) fSumw2.Set(fNcells);
5257 axis->SetTimeDisplay(timedisp);
5258 // reset histogram content
5259 Reset("ICE");
5260
5261 //now loop on all bins and refill
5262 // NOTE that if the bins without labels have content
5263 // it will be put in the underflow/overflow.
5264 // For this reason we use AddBinContent method
5265 Double_t oldEntries = fEntries;
5266 Int_t bin,binx,biny,binz;
5267 for (bin=0; bin < hold->fNcells; ++bin) {
5268 hold->GetBinXYZ(bin,binx,biny,binz);
5269 Int_t ibin = GetBin(binx,biny,binz);
5270 Double_t cu = hold->RetrieveBinContent(bin);
5271 AddBinContent(ibin,cu);
5272 if (errors) {
5273 fSumw2.fArray[ibin] += hold->fSumw2.fArray[bin];
5274 }
5275 }
5276 fEntries = oldEntries;
5277 delete hold;
5278}
5279
5280////////////////////////////////////////////////////////////////////////////////
5281/// Double the number of bins for axis.
5282/// Refill histogram.
5283/// This function is called by TAxis::FindBin(const char *label)
5284
5286{
5287 Int_t iaxis = AxisChoice(ax);
5288 TAxis *axis = nullptr;
5289 if (iaxis == 1) axis = GetXaxis();
5290 if (iaxis == 2) axis = GetYaxis();
5291 if (iaxis == 3) axis = GetZaxis();
5292 if (!axis) return;
5293
5294 TH1 *hold = (TH1*)IsA()->New();
5295 hold->SetDirectory(nullptr);
5296 Copy(*hold);
5297 hold->ResetBit(kMustCleanup);
5298
5299 Bool_t timedisp = axis->GetTimeDisplay();
5300 Int_t nbins = axis->GetNbins();
5301 Double_t xmin = axis->GetXmin();
5302 Double_t xmax = axis->GetXmax();
5303 xmax = xmin + 2*(xmax-xmin);
5304 axis->SetRange(0,0);
5305 // double the bins and recompute ncells
5306 axis->Set(2*nbins,xmin,xmax);
5307 SetBinsLength(-1);
5308 Int_t errors = fSumw2.fN;
5309 if (errors) fSumw2.Set(fNcells);
5310 axis->SetTimeDisplay(timedisp);
5311
5312 Reset("ICE"); // reset content and error
5313
5314 //now loop on all bins and refill
5315 Double_t oldEntries = fEntries;
5316 Int_t bin,ibin,binx,biny,binz;
5317 for (ibin =0; ibin < hold->fNcells; ibin++) {
5318 // get the binx,y,z values . The x-y-z (axis) bin values will stay the same between new-old after the expanding
5319 hold->GetBinXYZ(ibin,binx,biny,binz);
5320 bin = GetBin(binx,biny,binz);
5321
5322 // underflow and overflow will be cleaned up because their meaning has been altered
5323 if (hold->IsBinUnderflow(ibin,iaxis) || hold->IsBinOverflow(ibin,iaxis)) {
5324 continue;
5325 }
5326 else {
5327 AddBinContent(bin, hold->RetrieveBinContent(ibin));
5328 if (errors) fSumw2.fArray[bin] += hold->fSumw2.fArray[ibin];
5329 }
5330 }
5331 fEntries = oldEntries;
5332 delete hold;
5333}
5334
5335////////////////////////////////////////////////////////////////////////////////
5336/// Sort bins with labels or set option(s) to draw axis with labels
5337/// \param[in] option
5338/// - "a" sort by alphabetic order
5339/// - ">" sort by decreasing values
5340/// - "<" sort by increasing values
5341/// - "h" draw labels horizontal
5342/// - "v" draw labels vertical
5343/// - "u" draw labels up (end of label right adjusted)
5344/// - "d" draw labels down (start of label left adjusted)
5345///
5346/// In case not all bins have labels sorting will work only in the case
5347/// the first `n` consecutive bins have all labels and sorting will be performed on
5348/// those label bins.
5349///
5350/// \param[in] ax axis
5351
5353{
5354 Int_t iaxis = AxisChoice(ax);
5355 TAxis *axis = nullptr;
5356 if (iaxis == 1)
5357 axis = GetXaxis();
5358 if (iaxis == 2)
5359 axis = GetYaxis();
5360 if (iaxis == 3)
5361 axis = GetZaxis();
5362 if (!axis)
5363 return;
5364 THashList *labels = axis->GetLabels();
5365 if (!labels) {
5366 Warning("LabelsOption", "Axis %s has no labels!",axis->GetName());
5367 return;
5368 }
5369 TString opt = option;
5370 opt.ToLower();
5371 Int_t iopt = -1;
5372 if (opt.Contains("h")) {
5377 iopt = 0;
5378 }
5379 if (opt.Contains("v")) {
5384 iopt = 1;
5385 }
5386 if (opt.Contains("u")) {
5387 axis->SetBit(TAxis::kLabelsUp);
5391 iopt = 2;
5392 }
5393 if (opt.Contains("d")) {
5398 iopt = 3;
5399 }
5400 Int_t sort = -1;
5401 if (opt.Contains("a"))
5402 sort = 0;
5403 if (opt.Contains(">"))
5404 sort = 1;
5405 if (opt.Contains("<"))
5406 sort = 2;
5407 if (sort < 0) {
5408 if (iopt < 0)
5409 Error("LabelsOption", "%s is an invalid label placement option!",opt.Data());
5410 return;
5411 }
5412
5413 // Code works only if first n bins have labels if we uncomment following line
5414 // but we don't want to support this special case
5415 // Int_t n = TMath::Min(axis->GetNbins(), labels->GetSize());
5416
5417 // support only cases where each bin has a labels (should be when axis is alphanumeric)
5418 Int_t n = labels->GetSize();
5419 if (n != axis->GetNbins()) {
5420 // check if labels are all consecutive and starts from the first bin
5421 // in that case the current code will work fine
5422 Int_t firstLabelBin = axis->GetNbins()+1;
5423 Int_t lastLabelBin = -1;
5424 for (Int_t i = 0; i < n; ++i) {
5425 Int_t bin = labels->At(i)->GetUniqueID();
5426 if (bin < firstLabelBin) firstLabelBin = bin;
5427 if (bin > lastLabelBin) lastLabelBin = bin;
5428 }
5429 if (firstLabelBin != 1 || lastLabelBin-firstLabelBin +1 != n) {
5430 Error("LabelsOption", "%s of Histogram %s contains bins without labels. Sorting will not work correctly - return",
5431 axis->GetName(), GetName());
5432 return;
5433 }
5434 // case where label bins are consecutive starting from first bin will work
5435 // calling before a TH1::LabelsDeflate() will avoid this error message
5436 Warning("LabelsOption", "axis %s of Histogram %s has extra following bins without labels. Sorting will work only for first label bins",
5437 axis->GetName(), GetName());
5438 }
5439 std::vector<Int_t> a(n);
5440 std::vector<Int_t> b(n);
5441
5442
5443 Int_t i, j, k;
5444 std::vector<Double_t> cont;
5445 std::vector<Double_t> errors2;
5446 THashList *labold = new THashList(labels->GetSize(), 1);
5447 TIter nextold(labels);
5448 TObject *obj = nullptr;
5449 labold->AddAll(labels);
5450 labels->Clear();
5451
5452 // delete buffer if it is there since bins will be reordered.
5453 if (fBuffer)
5454 BufferEmpty(1);
5455
5456 if (sort > 0) {
5457 //---sort by values of bins
5458 if (GetDimension() == 1) {
5459 cont.resize(n);
5460 if (fSumw2.fN)
5461 errors2.resize(n);
5462 for (i = 0; i < n; i++) {
5463 cont[i] = RetrieveBinContent(i + 1);
5464 if (!errors2.empty())
5465 errors2[i] = GetBinErrorSqUnchecked(i + 1);
5466 b[i] = labold->At(i)->GetUniqueID(); // this is the bin corresponding to the label
5467 a[i] = i;
5468 }
5469 if (sort == 1)
5470 TMath::Sort(n, cont.data(), a.data(), kTRUE); // sort by decreasing values
5471 else
5472 TMath::Sort(n, cont.data(), a.data(), kFALSE); // sort by increasing values
5473 for (i = 0; i < n; i++) {
5474 // use UpdateBinCOntent to not screw up histogram entries
5475 UpdateBinContent(i + 1, cont[b[a[i]] - 1]); // b[a[i]] returns bin number. .we need to subtract 1
5476 if (gDebug)
5477 Info("LabelsOption","setting bin %d value %f from bin %d label %s at pos %d ",
5478 i+1,cont[b[a[i]] - 1],b[a[i]],labold->At(a[i])->GetName(),a[i]);
5479 if (!errors2.empty())
5480 fSumw2.fArray[i + 1] = errors2[b[a[i]] - 1];
5481 }
5482 for (i = 0; i < n; i++) {
5483 obj = labold->At(a[i]);
5484 labels->Add(obj);
5485 obj->SetUniqueID(i + 1);
5486 }
5487 } else if (GetDimension() == 2) {
5488 std::vector<Double_t> pcont(n + 2);
5489 Int_t nx = fXaxis.GetNbins() + 2;
5490 Int_t ny = fYaxis.GetNbins() + 2;
5491 cont.resize((nx + 2) * (ny + 2));
5492 if (fSumw2.fN)
5493 errors2.resize((nx + 2) * (ny + 2));
5494 for (i = 0; i < nx; i++) {
5495 for (j = 0; j < ny; j++) {
5496 Int_t bin = GetBin(i,j);
5497 cont[i + nx * j] = RetrieveBinContent(bin);
5498 if (!errors2.empty())
5499 errors2[i + nx * j] = GetBinErrorSqUnchecked(bin);
5500 if (axis == GetXaxis())
5501 k = i - 1;
5502 else
5503 k = j - 1;
5504 if (k >= 0 && k < n) { // we consider underflow/overflows in y for ordering the bins
5505 pcont[k] += cont[i + nx * j];
5506 a[k] = k;
5507 }
5508 }
5509 }
5510 if (sort == 1)
5511 TMath::Sort(n, pcont.data(), a.data(), kTRUE); // sort by decreasing values
5512 else
5513 TMath::Sort(n, pcont.data(), a.data(), kFALSE); // sort by increasing values
5514 for (i = 0; i < n; i++) {
5515 // iterate on old label list to find corresponding bin match
5516 TIter next(labold);
5517 UInt_t bin = a[i] + 1;
5518 while ((obj = next())) {
5519 if (obj->GetUniqueID() == (UInt_t)bin)
5520 break;
5521 else
5522 obj = nullptr;
5523 }
5524 if (!obj) {
5525 // this should not really happen
5526 R__ASSERT("LabelsOption - No corresponding bin found when ordering labels");
5527 return;
5528 }
5529
5530 labels->Add(obj);
5531 if (gDebug)
5532 std::cout << " set label " << obj->GetName() << " to bin " << i + 1 << " from order " << a[i] << " bin "
5533 << b[a[i]] << "content " << pcont[a[i]] << std::endl;
5534 }
5535 // need to set here new ordered labels - otherwise loop before does not work since labold and labels list
5536 // contain same objects
5537 for (i = 0; i < n; i++) {
5538 labels->At(i)->SetUniqueID(i + 1);
5539 }
5540 // set now the bin contents
5541 if (axis == GetXaxis()) {
5542 for (i = 0; i < n; i++) {
5543 Int_t ix = a[i] + 1;
5544 for (j = 0; j < ny; j++) {
5545 Int_t bin = GetBin(i + 1, j);
5546 UpdateBinContent(bin, cont[ix + nx * j]);
5547 if (!errors2.empty())
5548 fSumw2.fArray[bin] = errors2[ix + nx * j];
5549 }
5550 }
5551 } else {
5552 // using y axis
5553 for (i = 0; i < nx; i++) {
5554 for (j = 0; j < n; j++) {
5555 Int_t iy = a[j] + 1;
5556 Int_t bin = GetBin(i, j + 1);
5557 UpdateBinContent(bin, cont[i + nx * iy]);
5558 if (!errors2.empty())
5559 fSumw2.fArray[bin] = errors2[i + nx * iy];
5560 }
5561 }
5562 }
5563 } else {
5564 // sorting histograms: 3D case
5565 std::vector<Double_t> pcont(n + 2);
5566 Int_t nx = fXaxis.GetNbins() + 2;
5567 Int_t ny = fYaxis.GetNbins() + 2;
5568 Int_t nz = fZaxis.GetNbins() + 2;
5569 Int_t l = 0;
5570 cont.resize((nx + 2) * (ny + 2) * (nz + 2));
5571 if (fSumw2.fN)
5572 errors2.resize((nx + 2) * (ny + 2) * (nz + 2));
5573 for (i = 0; i < nx; i++) {
5574 for (j = 0; j < ny; j++) {
5575 for (k = 0; k < nz; k++) {
5576 Int_t bin = GetBin(i,j,k);
5578 if (axis == GetXaxis())
5579 l = i - 1;
5580 else if (axis == GetYaxis())
5581 l = j - 1;
5582 else
5583 l = k - 1;
5584 if (l >= 0 && l < n) { // we consider underflow/overflows in y for ordering the bins
5585 pcont[l] += c;
5586 a[l] = l;
5587 }
5588 cont[i + nx * (j + ny * k)] = c;
5589 if (!errors2.empty())
5590 errors2[i + nx * (j + ny * k)] = GetBinErrorSqUnchecked(bin);
5591 }
5592 }
5593 }
5594 if (sort == 1)
5595 TMath::Sort(n, pcont.data(), a.data(), kTRUE); // sort by decreasing values
5596 else
5597 TMath::Sort(n, pcont.data(), a.data(), kFALSE); // sort by increasing values
5598 for (i = 0; i < n; i++) {
5599 // iterate on the old label list to find corresponding bin match
5600 TIter next(labold);
5601 UInt_t bin = a[i] + 1;
5602 obj = nullptr;
5603 while ((obj = next())) {
5604 if (obj->GetUniqueID() == (UInt_t)bin) {
5605 break;
5606 }
5607 else
5608 obj = nullptr;
5609 }
5610 if (!obj) {
5611 R__ASSERT("LabelsOption - No corresponding bin found when ordering labels");
5612 return;
5613 }
5614 labels->Add(obj);
5615 if (gDebug)
5616 std::cout << " set label " << obj->GetName() << " to bin " << i + 1 << " from bin " << a[i] << "content "
5617 << pcont[a[i]] << std::endl;
5618 }
5619
5620 // need to set here new ordered labels - otherwise loop before does not work since labold and llabels list
5621 // contain same objects
5622 for (i = 0; i < n; i++) {
5623 labels->At(i)->SetUniqueID(i + 1);
5624 }
5625 // set now the bin contents
5626 if (axis == GetXaxis()) {
5627 for (i = 0; i < n; i++) {
5628 Int_t ix = a[i] + 1;
5629 for (j = 0; j < ny; j++) {
5630 for (k = 0; k < nz; k++) {
5631 Int_t bin = GetBin(i + 1, j, k);
5632 UpdateBinContent(bin, cont[ix + nx * (j + ny * k)]);
5633 if (!errors2.empty())
5634 fSumw2.fArray[bin] = errors2[ix + nx * (j + ny * k)];
5635 }
5636 }
5637 }
5638 } else if (axis == GetYaxis()) {
5639 // using y axis
5640 for (i = 0; i < nx; i++) {
5641 for (j = 0; j < n; j++) {
5642 Int_t iy = a[j] + 1;
5643 for (k = 0; k < nz; k++) {
5644 Int_t bin = GetBin(i, j + 1, k);
5645 UpdateBinContent(bin, cont[i + nx * (iy + ny * k)]);
5646 if (!errors2.empty())
5647 fSumw2.fArray[bin] = errors2[i + nx * (iy + ny * k)];
5648 }
5649 }
5650 }
5651 } else {
5652 // using z axis
5653 for (i = 0; i < nx; i++) {
5654 for (j = 0; j < ny; j++) {
5655 for (k = 0; k < n; k++) {
5656 Int_t iz = a[k] + 1;
5657 Int_t bin = GetBin(i, j , k +1);
5658 UpdateBinContent(bin, cont[i + nx * (j + ny * iz)]);
5659 if (!errors2.empty())
5660 fSumw2.fArray[bin] = errors2[i + nx * (j + ny * iz)];
5661 }
5662 }
5663 }
5664 }
5665 }
5666 } else {
5667 //---alphabetic sort
5668 // sort labels using vector of strings and TMath::Sort
5669 // I need to array because labels order in list is not necessary that of the bins
5670 std::vector<std::string> vecLabels(n);
5671 for (i = 0; i < n; i++) {
5672 vecLabels[i] = labold->At(i)->GetName();
5673 b[i] = labold->At(i)->GetUniqueID(); // this is the bin corresponding to the label
5674 a[i] = i;
5675 }
5676 // sort in ascending order for strings
5677 TMath::Sort(n, vecLabels.data(), a.data(), kFALSE);
5678 // set the new labels
5679 for (i = 0; i < n; i++) {
5680 TObject *labelObj = labold->At(a[i]);
5681 labels->Add(labold->At(a[i]));
5682 // set the corresponding bin. NB bin starts from 1
5683 labelObj->SetUniqueID(i + 1);
5684 if (gDebug)
5685 std::cout << "bin " << i + 1 << " setting new labels for axis " << labold->At(a[i])->GetName() << " from "
5686 << b[a[i]] << std::endl;
5687 }
5688
5689 if (GetDimension() == 1) {
5690 cont.resize(n + 2);
5691 if (fSumw2.fN)
5692 errors2.resize(n + 2);
5693 for (i = 0; i < n; i++) {
5694 cont[i] = RetrieveBinContent(b[a[i]]);
5695 if (!errors2.empty())
5696 errors2[i] = GetBinErrorSqUnchecked(b[a[i]]);
5697 }
5698 for (i = 0; i < n; i++) {
5699 UpdateBinContent(i + 1, cont[i]);
5700 if (!errors2.empty())
5701 fSumw2.fArray[i+1] = errors2[i];
5702 }
5703 } else if (GetDimension() == 2) {
5704 Int_t nx = fXaxis.GetNbins() + 2;
5705 Int_t ny = fYaxis.GetNbins() + 2;
5706 cont.resize(nx * ny);
5707 if (fSumw2.fN)
5708 errors2.resize(nx * ny);
5709 // copy old bin contents and then set to new ordered bins
5710 // N.B. bin in histograms starts from 1, but in y we consider under/overflows
5711 for (i = 0; i < nx; i++) {
5712 for (j = 0; j < ny; j++) { // ny is nbins+2
5713 Int_t bin = GetBin(i, j);
5714 cont[i + nx * j] = RetrieveBinContent(bin);
5715 if (!errors2.empty())
5716 errors2[i + nx * j] = GetBinErrorSqUnchecked(bin);
5717 }
5718 }
5719 if (axis == GetXaxis()) {
5720 for (i = 0; i < n; i++) {
5721 for (j = 0; j < ny; j++) {
5722 Int_t bin = GetBin(i + 1 , j);
5723 UpdateBinContent(bin, cont[b[a[i]] + nx * j]);
5724 if (!errors2.empty())
5725 fSumw2.fArray[bin] = errors2[b[a[i]] + nx * j];
5726 }
5727 }
5728 } else {
5729 for (i = 0; i < nx; i++) {
5730 for (j = 0; j < n; j++) {
5731 Int_t bin = GetBin(i, j + 1);
5732 UpdateBinContent(bin, cont[i + nx * b[a[j]]]);
5733 if (!errors2.empty())
5734 fSumw2.fArray[bin] = errors2[i + nx * b[a[j]]];
5735 }
5736 }
5737 }
5738 } else {
5739 // case of 3D (needs to be tested)
5740 Int_t nx = fXaxis.GetNbins() + 2;
5741 Int_t ny = fYaxis.GetNbins() + 2;
5742 Int_t nz = fZaxis.GetNbins() + 2;
5743 cont.resize(nx * ny * nz);
5744 if (fSumw2.fN)
5745 errors2.resize(nx * ny * nz);
5746 for (i = 0; i < nx; i++) {
5747 for (j = 0; j < ny; j++) {
5748 for (k = 0; k < nz; k++) {
5749 Int_t bin = GetBin(i, j, k);
5750 cont[i + nx * (j + ny * k)] = RetrieveBinContent(bin);
5751 if (!errors2.empty())
5752 errors2[i + nx * (j + ny * k)] = GetBinErrorSqUnchecked(bin);
5753 }
5754 }
5755 }
5756 if (axis == GetXaxis()) {
5757 // labels on x axis
5758 for (i = 0; i < n; i++) { // for x we loop only on bins with the labels
5759 for (j = 0; j < ny; j++) {
5760 for (k = 0; k < nz; k++) {
5761 Int_t bin = GetBin(i + 1, j, k);
5762 UpdateBinContent(bin, cont[b[a[i]] + nx * (j + ny * k)]);
5763 if (!errors2.empty())
5764 fSumw2.fArray[bin] = errors2[b[a[i]] + nx * (j + ny * k)];
5765 }
5766 }
5767 }
5768 } else if (axis == GetYaxis()) {
5769 // labels on y axis
5770 for (i = 0; i < nx; i++) {
5771 for (j = 0; j < n; j++) {
5772 for (k = 0; k < nz; k++) {
5773 Int_t bin = GetBin(i, j+1, k);
5774 UpdateBinContent(bin, cont[i + nx * (b[a[j]] + ny * k)]);
5775 if (!errors2.empty())
5776 fSumw2.fArray[bin] = errors2[i + nx * (b[a[j]] + ny * k)];
5777 }
5778 }
5779 }
5780 } else {
5781 // labels on z axis
5782 for (i = 0; i < nx; i++) {
5783 for (j = 0; j < ny; j++) {
5784 for (k = 0; k < n; k++) {
5785 Int_t bin = GetBin(i, j, k+1);
5786 UpdateBinContent(bin, cont[i + nx * (j + ny * b[a[k]])]);
5787 if (!errors2.empty())
5788 fSumw2.fArray[bin] = errors2[i + nx * (j + ny * b[a[k]])];
5789 }
5790 }
5791 }
5792 }
5793 }
5794 }
5795 // need to set to zero the statistics if axis has been sorted
5796 // see for example TH3::PutStats for definition of s vector
5797 bool labelsAreSorted = kFALSE;
5798 for (i = 0; i < n; ++i) {
5799 if (a[i] != i) {
5800 labelsAreSorted = kTRUE;
5801 break;
5802 }
5803 }
5804 if (labelsAreSorted) {
5805 double s[TH1::kNstat];
5806 GetStats(s);
5807 if (iaxis == 1) {
5808 s[2] = 0; // fTsumwx
5809 s[3] = 0; // fTsumwx2
5810 s[6] = 0; // fTsumwxy
5811 s[9] = 0; // fTsumwxz
5812 } else if (iaxis == 2) {
5813 s[4] = 0; // fTsumwy
5814 s[5] = 0; // fTsumwy2
5815 s[6] = 0; // fTsumwxy
5816 s[10] = 0; // fTsumwyz
5817 } else if (iaxis == 3) {
5818 s[7] = 0; // fTsumwz
5819 s[8] = 0; // fTsumwz2
5820 s[9] = 0; // fTsumwxz
5821 s[10] = 0; // fTsumwyz
5822 }
5823 PutStats(s);
5824 }
5825 delete labold;
5826}
5827
5828////////////////////////////////////////////////////////////////////////////////
5829/// Test if two double are almost equal.
5830
5831static inline Bool_t AlmostEqual(Double_t a, Double_t b, Double_t epsilon = 0.00000001)
5832{
5833 return TMath::Abs(a - b) < epsilon;
5834}
5835
5836////////////////////////////////////////////////////////////////////////////////
5837/// Test if a double is almost an integer.
5838
5839static inline Bool_t AlmostInteger(Double_t a, Double_t epsilon = 0.00000001)
5840{
5841 return AlmostEqual(a - TMath::Floor(a), 0, epsilon) ||
5842 AlmostEqual(a - TMath::Floor(a), 1, epsilon);
5843}
5844
5845////////////////////////////////////////////////////////////////////////////////
5846/// Test if the binning is equidistant.
5847
5848static inline bool IsEquidistantBinning(const TAxis& axis)
5849{
5850 // check if axis bin are equals
5851 if (!axis.GetXbins()->fN) return true; //
5852 // not able to check if there is only one axis entry
5853 bool isEquidistant = true;
5854 const Double_t firstBinWidth = axis.GetBinWidth(1);
5855 for (int i = 1; i < axis.GetNbins(); ++i) {
5856 const Double_t binWidth = axis.GetBinWidth(i);
5857 const bool match = TMath::AreEqualRel(firstBinWidth, binWidth, 1.E-10);
5858 isEquidistant &= match;
5859 if (!match)
5860 break;
5861 }
5862 return isEquidistant;
5863}
5864
5865////////////////////////////////////////////////////////////////////////////////
5866/// Same limits and bins.
5867
5868Bool_t TH1::SameLimitsAndNBins(const TAxis &axis1, const TAxis &axis2){
5869 return axis1.GetNbins() == axis2.GetNbins() &&
5870 TMath::AreEqualAbs(axis1.GetXmin(), axis2.GetXmin(), axis1.GetBinWidth(axis1.GetNbins()) * 1.E-10) &&
5871 TMath::AreEqualAbs(axis1.GetXmax(), axis2.GetXmax(), axis1.GetBinWidth(axis1.GetNbins()) * 1.E-10);
5872}
5873
5874////////////////////////////////////////////////////////////////////////////////
5875/// Finds new limits for the axis for the Merge function.
5876/// returns false if the limits are incompatible
5877
5878Bool_t TH1::RecomputeAxisLimits(TAxis &destAxis, const TAxis &anAxis)
5879{
5880 if (SameLimitsAndNBins(destAxis, anAxis))
5881 return kTRUE;
5882
5883 if (!IsEquidistantBinning(destAxis) || !IsEquidistantBinning(anAxis))
5884 return kFALSE; // not equidistant user binning not supported
5885
5886 Double_t width1 = destAxis.GetBinWidth(0);
5887 Double_t width2 = anAxis.GetBinWidth(0);
5888 if (width1 == 0 || width2 == 0)
5889 return kFALSE; // no binning not supported
5890
5891 Double_t xmin = TMath::Min(destAxis.GetXmin(), anAxis.GetXmin());
5892 Double_t xmax = TMath::Max(destAxis.GetXmax(), anAxis.GetXmax());
5893 Double_t width = TMath::Max(width1, width2);
5894
5895 // check the bin size
5896 if (!AlmostInteger(width/width1) || !AlmostInteger(width/width2))
5897 return kFALSE;
5898
5899 // std::cout << "Find new limit using given axis " << anAxis.GetXmin() << " , " << anAxis.GetXmax() << " bin width " << width2 << std::endl;
5900 // std::cout << " and destination axis " << destAxis.GetXmin() << " , " << destAxis.GetXmax() << " bin width " << width1 << std::endl;
5901
5902
5903 // check the limits
5904 Double_t delta;
5905 delta = (destAxis.GetXmin() - xmin)/width1;
5906 if (!AlmostInteger(delta))
5907 xmin -= (TMath::Ceil(delta) - delta)*width1;
5908
5909 delta = (anAxis.GetXmin() - xmin)/width2;
5910 if (!AlmostInteger(delta))
5911 xmin -= (TMath::Ceil(delta) - delta)*width2;
5912
5913
5914 delta = (destAxis.GetXmin() - xmin)/width1;
5915 if (!AlmostInteger(delta))
5916 return kFALSE;
5917
5918
5919 delta = (xmax - destAxis.GetXmax())/width1;
5920 if (!AlmostInteger(delta))
5921 xmax += (TMath::Ceil(delta) - delta)*width1;
5922
5923
5924 delta = (xmax - anAxis.GetXmax())/width2;
5925 if (!AlmostInteger(delta))
5926 xmax += (TMath::Ceil(delta) - delta)*width2;
5927
5928
5929 delta = (xmax - destAxis.GetXmax())/width1;
5930 if (!AlmostInteger(delta))
5931 return kFALSE;
5932#ifdef DEBUG
5933 if (!AlmostInteger((xmax - xmin) / width)) { // unnecessary check
5934 printf("TH1::RecomputeAxisLimits - Impossible\n");
5935 return kFALSE;
5936 }
5937#endif
5938
5939
5940 destAxis.Set(TMath::Nint((xmax - xmin)/width), xmin, xmax);
5941
5942 //std::cout << "New re-computed axis : [ " << xmin << " , " << xmax << " ] width = " << width << " nbins " << destAxis.GetNbins() << std::endl;
5943
5944 return kTRUE;
5945}
5946
5947////////////////////////////////////////////////////////////////////////////////
5948/// Add all histograms in the collection to this histogram.
5949/// This function computes the min/max for the x axis,
5950/// compute a new number of bins, if necessary,
5951/// add bin contents, errors and statistics.
5952/// If all histograms have bin labels, bins with identical labels
5953/// will be merged, no matter what their order is.
5954/// If overflows are present and limits are different the function will fail.
5955/// The function returns the total number of entries in the result histogram
5956/// if the merge is successful, -1 otherwise.
5957///
5958/// Possible option:
5959/// -NOL : the merger will ignore the labels and merge the histograms bin by bin using bin center values to match bins
5960/// -NOCHECK: the histogram will not perform a check for duplicate labels in case of axes with labels. The check
5961/// (enabled by default) slows down the merging
5962///
5963/// IMPORTANT remark. The axis x may have different number
5964/// of bins and different limits, BUT the largest bin width must be
5965/// a multiple of the smallest bin width and the upper limit must also
5966/// be a multiple of the bin width.
5967/// Example:
5968///
5969/// ~~~ {.cpp}
5970/// void atest() {
5971/// TH1F *h1 = new TH1F("h1","h1",110,-110,0);
5972/// TH1F *h2 = new TH1F("h2","h2",220,0,110);
5973/// TH1F *h3 = new TH1F("h3","h3",330,-55,55);
5974/// TRandom r;
5975/// for (Int_t i=0;i<10000;i++) {
5976/// h1->Fill(r.Gaus(-55,10));
5977/// h2->Fill(r.Gaus(55,10));
5978/// h3->Fill(r.Gaus(0,10));
5979/// }
5980///
5981/// TList *list = new TList;
5982/// list->Add(h1);
5983/// list->Add(h2);
5984/// list->Add(h3);
5985/// TH1F *h = (TH1F*)h1->Clone("h");
5986/// h->Reset();
5987/// h->Merge(list);
5988/// h->Draw();
5989/// }
5990/// ~~~
5991
5993{
5994 if (!li) return 0;
5995 if (li->IsEmpty()) return (Long64_t) GetEntries();
5996
5997 // use TH1Merger class
5998 TH1Merger merger(*this,*li,opt);
5999 Bool_t ret = merger();
6000
6001 return (ret) ? GetEntries() : -1;
6002}
6003
6004
6005////////////////////////////////////////////////////////////////////////////////
6006/// Performs the operation:
6007///
6008/// `this = this*c1*f1`
6009///
6010/// If errors are defined (see TH1::Sumw2), errors are also recalculated.
6011///
6012/// Only bins inside the function range are recomputed.
6013/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
6014/// you should call Sumw2 before making this operation.
6015/// This is particularly important if you fit the histogram after TH1::Multiply
6016///
6017/// The function return kFALSE if the Multiply operation failed
6018
6020{
6021 if (!f1) {
6022 Error("Multiply","Attempt to multiply by a non-existing function");
6023 return kFALSE;
6024 }
6025
6026 // delete buffer if it is there since it will become invalid
6027 if (fBuffer) BufferEmpty(1);
6028
6029 Int_t nx = GetNbinsX() + 2; // normal bins + uf / of (cells)
6030 Int_t ny = GetNbinsY() + 2;
6031 Int_t nz = GetNbinsZ() + 2;
6032 if (fDimension < 2) ny = 1;
6033 if (fDimension < 3) nz = 1;
6034
6035 // reset min-maximum
6036 SetMinimum();
6037 SetMaximum();
6038
6039 // - Loop on bins (including underflows/overflows)
6040 Double_t xx[3];
6041 Double_t *params = nullptr;
6042 f1->InitArgs(xx,params);
6043
6044 for (Int_t binz = 0; binz < nz; ++binz) {
6045 xx[2] = fZaxis.GetBinCenter(binz);
6046 for (Int_t biny = 0; biny < ny; ++biny) {
6047 xx[1] = fYaxis.GetBinCenter(biny);
6048 for (Int_t binx = 0; binx < nx; ++binx) {
6049 xx[0] = fXaxis.GetBinCenter(binx);
6050 if (!f1->IsInside(xx)) continue;
6052 Int_t bin = binx + nx * (biny + ny *binz);
6053 Double_t cu = c1*f1->EvalPar(xx);
6054 if (TF1::RejectedPoint()) continue;
6055 UpdateBinContent(bin, RetrieveBinContent(bin) * cu);
6056 if (fSumw2.fN) {
6057 fSumw2.fArray[bin] = cu * cu * GetBinErrorSqUnchecked(bin);
6058 }
6059 }
6060 }
6061 }
6062 ResetStats();
6063 return kTRUE;
6064}
6065
6066////////////////////////////////////////////////////////////////////////////////
6067/// Multiply this histogram by h1.
6068///
6069/// `this = this*h1`
6070///
6071/// If errors of this are available (TH1::Sumw2), errors are recalculated.
6072/// Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
6073/// if not already set.
6074///
6075/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
6076/// you should call Sumw2 before making this operation.
6077/// This is particularly important if you fit the histogram after TH1::Multiply
6078///
6079/// The function return kFALSE if the Multiply operation failed
6080
6081Bool_t TH1::Multiply(const TH1 *h1)
6082{
6083 if (!h1) {
6084 Error("Multiply","Attempt to multiply by a non-existing histogram");
6085 return kFALSE;
6086 }
6087
6088 // delete buffer if it is there since it will become invalid
6089 if (fBuffer) BufferEmpty(1);
6090
6091 if (LoggedInconsistency("Multiply", this, h1) >= kDifferentNumberOfBins) {
6092 return false;
6093 }
6094
6095 // Create Sumw2 if h1 has Sumw2 set
6096 if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();
6097
6098 // - Reset min- maximum
6099 SetMinimum();
6100 SetMaximum();
6101
6102 // - Loop on bins (including underflows/overflows)
6103 for (Int_t i = 0; i < fNcells; ++i) {
6106 UpdateBinContent(i, c0 * c1);
6107 if (fSumw2.fN) {
6109 }
6110 }
6111 ResetStats();
6112 return kTRUE;
6113}
6114
6115////////////////////////////////////////////////////////////////////////////////
6116/// Replace contents of this histogram by multiplication of h1 by h2.
6117///
6118/// `this = (c1*h1)*(c2*h2)`
6119///
6120/// If errors of this are available (TH1::Sumw2), errors are recalculated.
6121/// Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
6122/// if not already set.
6123///
6124/// IMPORTANT NOTE: If you intend to use the errors of this histogram later
6125/// you should call Sumw2 before making this operation.
6126/// This is particularly important if you fit the histogram after TH1::Multiply
6127///
6128/// The function return kFALSE if the Multiply operation failed
6129
6131{
6132 TString opt = option;
6133 opt.ToLower();
6134 // Bool_t binomial = kFALSE;
6135 // if (opt.Contains("b")) binomial = kTRUE;
6136 if (!h1 || !h2) {
6137 Error("Multiply","Attempt to multiply by a non-existing histogram");
6138 return kFALSE;
6139 }
6140
6141 // delete buffer if it is there since it will become invalid
6142 if (fBuffer) BufferEmpty(1);
6143
6144 if (LoggedInconsistency("Multiply", this, h1) >= kDifferentNumberOfBins ||
6145 LoggedInconsistency("Multiply", h1, h2) >= kDifferentNumberOfBins) {
6146 return false;
6147 }
6148
6149 // Create Sumw2 if h1 or h2 have Sumw2 set
6150 if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();
6151
6152 // - Reset min - maximum
6153 SetMinimum();
6154 SetMaximum();
6155
6156 // - Loop on bins (including underflows/overflows)
6157 Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
6158 for (Int_t i = 0; i < fNcells; ++i) {
6160 Double_t b2 = h2->RetrieveBinContent(i);
6161 UpdateBinContent(i, c1 * b1 * c2 * b2);
6162 if (fSumw2.fN) {
6163 fSumw2.fArray[i] = c1sq * c2sq * (h1->GetBinErrorSqUnchecked(i) * b2 * b2 + h2->GetBinErrorSqUnchecked(i) * b1 * b1);
6164 }
6165 }
6166 ResetStats();
6167 return kTRUE;
6168}
6169
6170////////////////////////////////////////////////////////////////////////////////
6171/// Control routine to paint any kind of histograms.
6172///
6173/// This function is automatically called by TCanvas::Update.
6174/// (see TH1::Draw for the list of options)
6175
6177{
6179
6180 if (fPainter) {
6181 if (option && strlen(option) > 0)
6183 else
6185 }
6186}
6187
6188////////////////////////////////////////////////////////////////////////////////
6189/// Rebin this histogram
6190///
6191/// #### case 1 xbins=0
6192///
6193/// If newname is blank (default), the current histogram is modified and
6194/// a pointer to it is returned.
6195///
6196/// If newname is not blank, the current histogram is not modified, and a
6197/// new histogram is returned which is a Clone of the current histogram
6198/// with its name set to newname.
6199///
6200/// The parameter ngroup indicates how many bins of this have to be merged
6201/// into one bin of the result.
6202///
6203/// If the original histogram has errors stored (via Sumw2), the resulting
6204/// histograms has new errors correctly calculated.
6205///
6206/// examples: if h1 is an existing TH1F histogram with 100 bins
6207///
6208/// ~~~ {.cpp}
6209/// h1->Rebin(); //merges two bins in one in h1: previous contents of h1 are lost
6210/// h1->Rebin(5); //merges five bins in one in h1
6211/// TH1F *hnew = dynamic_cast<TH1F*>(h1->Rebin(5,"hnew")); // creates a new histogram hnew
6212/// // merging 5 bins of h1 in one bin
6213/// ~~~
6214///
6215/// NOTE: If ngroup is not an exact divider of the number of bins,
6216/// the top limit of the rebinned histogram is reduced
6217/// to the upper edge of the last bin that can make a complete
6218/// group. The remaining bins are added to the overflow bin.
6219/// Statistics will be recomputed from the new bin contents.
6220///
6221/// #### case 2 xbins!=0
6222///
6223/// A new histogram is created (you should specify newname).
6224/// The parameter ngroup is the number of variable size bins in the created histogram.
6225/// The array xbins must contain ngroup+1 elements that represent the low-edges
6226/// of the bins.
6227/// If the original histogram has errors stored (via Sumw2), the resulting
6228/// histograms has new errors correctly calculated.
6229///
6230/// NOTE: The bin edges specified in xbins should correspond to bin edges
6231/// in the original histogram. If a bin edge in the new histogram is
6232/// in the middle of a bin in the original histogram, all entries in
6233/// the split bin in the original histogram will be transfered to the
6234/// lower of the two possible bins in the new histogram. This is
6235/// probably not what you want. A warning message is emitted in this
6236/// case
6237///
6238/// examples: if h1 is an existing TH1F histogram with 100 bins
6239///
6240/// ~~~ {.cpp}
6241/// Double_t xbins[25] = {...} array of low-edges (xbins[25] is the upper edge of last bin
6242/// h1->Rebin(24,"hnew",xbins); //creates a new variable bin size histogram hnew
6243/// ~~~
6244
6245TH1 *TH1::Rebin(Int_t ngroup, const char*newname, const Double_t *xbins)
6246{
6247 Int_t nbins = fXaxis.GetNbins();
6250 if ((ngroup <= 0) || (ngroup > nbins)) {
6251 Error("Rebin", "Illegal value of ngroup=%d",ngroup);
6252 return nullptr;
6253 }
6254
6255 if (fDimension > 1 || InheritsFrom(TProfile::Class())) {
6256 Error("Rebin", "Operation valid on 1-D histograms only");
6257 return nullptr;
6258 }
6259 if (!newname && xbins) {
6260 Error("Rebin","if xbins is specified, newname must be given");
6261 return nullptr;
6262 }
6263
6264 Int_t newbins = nbins/ngroup;
6265 if (!xbins) {
6266 Int_t nbg = nbins/ngroup;
6267 if (nbg*ngroup != nbins) {
6268 Warning("Rebin", "ngroup=%d is not an exact divider of nbins=%d.",ngroup,nbins);
6269 }
6270 }
6271 else {
6272 // in the case that xbins is given (rebinning in variable bins), ngroup is
6273 // the new number of bins and number of grouped bins is not constant.
6274 // when looping for setting the contents for the new histogram we
6275 // need to loop on all bins of original histogram. Then set ngroup=nbins
6276 newbins = ngroup;
6277 ngroup = nbins;
6278 }
6279
6280 // Save old bin contents into a new array
6281 Double_t entries = fEntries;
6282 Double_t *oldBins = new Double_t[nbins+2];
6283 Int_t bin, i;
6284 for (bin=0;bin<nbins+2;bin++) oldBins[bin] = RetrieveBinContent(bin);
6285 Double_t *oldErrors = nullptr;
6286 if (fSumw2.fN != 0) {
6287 oldErrors = new Double_t[nbins+2];
6288 for (bin=0;bin<nbins+2;bin++) oldErrors[bin] = GetBinError(bin);
6289 }
6290 // rebin will not include underflow/overflow if new axis range is larger than old axis range
6291 if (xbins) {
6292 if (xbins[0] < fXaxis.GetXmin() && oldBins[0] != 0 )
6293 Warning("Rebin","underflow entries will not be used when rebinning");
6294 if (xbins[newbins] > fXaxis.GetXmax() && oldBins[nbins+1] != 0 )
6295 Warning("Rebin","overflow entries will not be used when rebinning");
6296 }
6297
6298
6299 // create a clone of the old histogram if newname is specified
6300 TH1 *hnew = this;
6301 if ((newname && strlen(newname) > 0) || xbins) {
6302 hnew = (TH1*)Clone(newname);
6303 }
6304
6305 //reset can extend bit to avoid an axis extension in SetBinContent
6306 UInt_t oldExtendBitMask = hnew->SetCanExtend(kNoAxis);
6307
6308 // save original statistics
6309 Double_t stat[kNstat];
6310 GetStats(stat);
6311 bool resetStat = false;
6312 // change axis specs and rebuild bin contents array::RebinAx
6313 if(!xbins && (newbins*ngroup != nbins)) {
6314 xmax = fXaxis.GetBinUpEdge(newbins*ngroup);
6315 resetStat = true; //stats must be reset because top bins will be moved to overflow bin
6316 }
6317 // save the TAttAxis members (reset by SetBins)
6318 Int_t nDivisions = fXaxis.GetNdivisions();
6319 Color_t axisColor = fXaxis.GetAxisColor();
6320 Color_t labelColor = fXaxis.GetLabelColor();
6321 Style_t labelFont = fXaxis.GetLabelFont();
6322 Float_t labelOffset = fXaxis.GetLabelOffset();
6323 Float_t labelSize = fXaxis.GetLabelSize();
6324 Float_t tickLength = fXaxis.GetTickLength();
6325 Float_t titleOffset = fXaxis.GetTitleOffset();
6326 Float_t titleSize = fXaxis.GetTitleSize();
6327 Color_t titleColor = fXaxis.GetTitleColor();
6328 Style_t titleFont = fXaxis.GetTitleFont();
6329
6330 if(!xbins && (fXaxis.GetXbins()->GetSize() > 0)){ // variable bin sizes
6331 Double_t *bins = new Double_t[newbins+1];
6332 for(i = 0; i <= newbins; ++i) bins[i] = fXaxis.GetBinLowEdge(1+i*ngroup);
6333 hnew->SetBins(newbins,bins); //this also changes errors array (if any)
6334 delete [] bins;
6335 } else if (xbins) {
6336 hnew->SetBins(newbins,xbins);
6337 } else {
6338 hnew->SetBins(newbins,xmin,xmax);
6339 }
6340
6341 // Restore axis attributes
6342 fXaxis.SetNdivisions(nDivisions);
6343 fXaxis.SetAxisColor(axisColor);
6344 fXaxis.SetLabelColor(labelColor);
6345 fXaxis.SetLabelFont(labelFont);
6346 fXaxis.SetLabelOffset(labelOffset);
6347 fXaxis.SetLabelSize(labelSize);
6348 fXaxis.SetTickLength(tickLength);
6349 fXaxis.SetTitleOffset(titleOffset);
6350 fXaxis.SetTitleSize(titleSize);
6351 fXaxis.SetTitleColor(titleColor);
6352 fXaxis.SetTitleFont(titleFont);
6353
6354 // copy merged bin contents (ignore under/overflows)
6355 // Start merging only once the new lowest edge is reached
6356 Int_t startbin = 1;
6357 const Double_t newxmin = hnew->GetXaxis()->GetBinLowEdge(1);
6358 while( fXaxis.GetBinCenter(startbin) < newxmin && startbin <= nbins ) {
6359 startbin++;
6360 }
6361 Int_t oldbin = startbin;
6362 Double_t binContent, binError;
6363 for (bin = 1;bin<=newbins;bin++) {
6364 binContent = 0;
6365 binError = 0;
6366 Int_t imax = ngroup;
6367 Double_t xbinmax = hnew->GetXaxis()->GetBinUpEdge(bin);
6368 // check bin edges for the cases when we provide an array of bins
6369 // be careful in case bins can have zero width
6370 if (xbins && !TMath::AreEqualAbs(fXaxis.GetBinLowEdge(oldbin),
6371 hnew->GetXaxis()->GetBinLowEdge(bin),
6372 TMath::Max(1.E-8 * fXaxis.GetBinWidth(oldbin), 1.E-16 )) )
6373 {
6374 Warning("Rebin","Bin edge %d of rebinned histogram does not match any bin edges of the old histogram. Result can be inconsistent",bin);
6375 }
6376 for (i=0;i<ngroup;i++) {
6377 if( (oldbin+i > nbins) ||
6378 ( hnew != this && (fXaxis.GetBinCenter(oldbin+i) > xbinmax)) ) {
6379 imax = i;
6380 break;
6381 }
6382 binContent += oldBins[oldbin+i];
6383 if (oldErrors) binError += oldErrors[oldbin+i]*oldErrors[oldbin+i];
6384 }
6385 hnew->SetBinContent(bin,binContent);
6386 if (oldErrors) hnew->SetBinError(bin,TMath::Sqrt(binError));
6387 oldbin += imax;
6388 }
6389
6390 // sum underflow and overflow contents until startbin
6391 binContent = 0;
6392 binError = 0;
6393 for (i = 0; i < startbin; ++i) {
6394 binContent += oldBins[i];
6395 if (oldErrors) binError += oldErrors[i]*oldErrors[i];
6396 }
6397 hnew->SetBinContent(0,binContent);
6398 if (oldErrors) hnew->SetBinError(0,TMath::Sqrt(binError));
6399 // sum overflow
6400 binContent = 0;
6401 binError = 0;
6402 for (i = oldbin; i <= nbins+1; ++i) {
6403 binContent += oldBins[i];
6404 if (oldErrors) binError += oldErrors[i]*oldErrors[i];
6405 }
6406 hnew->SetBinContent(newbins+1,binContent);
6407 if (oldErrors) hnew->SetBinError(newbins+1,TMath::Sqrt(binError));
6408
6409 hnew->SetCanExtend(oldExtendBitMask); // restore previous state
6410
6411 // restore statistics and entries modified by SetBinContent
6412 hnew->SetEntries(entries);
6413 if (!resetStat) hnew->PutStats(stat);
6414 delete [] oldBins;
6415 if (oldErrors) delete [] oldErrors;
6416 return hnew;
6417}
6418
6419////////////////////////////////////////////////////////////////////////////////
6420/// finds new limits for the axis so that *point* is within the range and
6421/// the limits are compatible with the previous ones (see TH1::Merge).
6422/// new limits are put into *newMin* and *newMax* variables.
6423/// axis - axis whose limits are to be recomputed
6424/// point - point that should fit within the new axis limits
6425/// newMin - new minimum will be stored here
6426/// newMax - new maximum will be stored here.
6427/// false if failed (e.g. if the initial axis limits are wrong
6428/// or the new range is more than \f$ 2^{64} \f$ times the old one).
6429
6430Bool_t TH1::FindNewAxisLimits(const TAxis* axis, const Double_t point, Double_t& newMin, Double_t &newMax)
6431{
6432 Double_t xmin = axis->GetXmin();
6433 Double_t xmax = axis->GetXmax();
6434 if (xmin >= xmax) return kFALSE;
6435 Double_t range = xmax-xmin;
6436
6437 //recompute new axis limits by doubling the current range
6438 Int_t ntimes = 0;
6439 while (point < xmin) {
6440 if (ntimes++ > 64)
6441 return kFALSE;
6442 xmin = xmin - range;
6443 range *= 2;
6444 }
6445 while (point >= xmax) {
6446 if (ntimes++ > 64)
6447 return kFALSE;
6448 xmax = xmax + range;
6449 range *= 2;
6450 }
6451 newMin = xmin;
6452 newMax = xmax;
6453 // Info("FindNewAxisLimits", "OldAxis: (%lf, %lf), new: (%lf, %lf), point: %lf",
6454 // axis->GetXmin(), axis->GetXmax(), xmin, xmax, point);
6455
6456 return kTRUE;
6457}
6458
6459////////////////////////////////////////////////////////////////////////////////
6460/// Histogram is resized along axis such that x is in the axis range.
6461/// The new axis limits are recomputed by doubling iteratively
6462/// the current axis range until the specified value x is within the limits.
6463/// The algorithm makes a copy of the histogram, then loops on all bins
6464/// of the old histogram to fill the extended histogram.
6465/// Takes into account errors (Sumw2) if any.
6466/// The algorithm works for 1-d, 2-D and 3-D histograms.
6467/// The axis must be extendable before invoking this function.
6468/// Ex:
6469///
6470/// ~~~ {.cpp}
6471/// h->GetXaxis()->SetCanExtend(kTRUE);
6472/// ~~~
6473
6474void TH1::ExtendAxis(Double_t x, TAxis *axis)
6475{
6476 if (!axis->CanExtend()) return;
6477 if (TMath::IsNaN(x)) { // x may be a NaN
6479 return;
6480 }
6481
6482 if (axis->GetXmin() >= axis->GetXmax()) return;
6483 if (axis->GetNbins() <= 0) return;
6484
6486 if (!FindNewAxisLimits(axis, x, xmin, xmax))
6487 return;
6488
6489 //save a copy of this histogram
6490 TH1 *hold = (TH1*)IsA()->New();
6491 hold->SetDirectory(nullptr);
6492 Copy(*hold);
6493 //set new axis limits
6494 axis->SetLimits(xmin,xmax);
6495
6496
6497 //now loop on all bins and refill
6498 Int_t errors = GetSumw2N();
6499
6500 Reset("ICE"); //reset only Integral, contents and Errors
6501
6502 int iaxis = 0;
6503 if (axis == &fXaxis) iaxis = 1;
6504 if (axis == &fYaxis) iaxis = 2;
6505 if (axis == &fZaxis) iaxis = 3;
6506 bool firstw = kTRUE;
6507 Int_t binx,biny, binz = 0;
6508 Int_t ix = 0,iy = 0,iz = 0;
6509 Double_t bx,by,bz;
6510 Int_t ncells = hold->GetNcells();
6511 for (Int_t bin = 0; bin < ncells; ++bin) {
6512 hold->GetBinXYZ(bin,binx,biny,binz);
6513 bx = hold->GetXaxis()->GetBinCenter(binx);
6514 ix = fXaxis.FindFixBin(bx);
6515 if (fDimension > 1) {
6516 by = hold->GetYaxis()->GetBinCenter(biny);
6517 iy = fYaxis.FindFixBin(by);
6518 if (fDimension > 2) {
6519 bz = hold->GetZaxis()->GetBinCenter(binz);
6520 iz = fZaxis.FindFixBin(bz);
6521 }
6522 }
6523 // exclude underflow/overflow
6524 double content = hold->RetrieveBinContent(bin);
6525 if (content == 0) continue;
6526 if (IsBinUnderflow(bin,iaxis) || IsBinOverflow(bin,iaxis) ) {
6527 if (firstw) {
6528 Warning("ExtendAxis","Histogram %s has underflow or overflow in the axis that is extendable"
6529 " their content will be lost",GetName() );
6530 firstw= kFALSE;
6531 }
6532 continue;
6533 }
6534 Int_t ibin= GetBin(ix,iy,iz);
6535 AddBinContent(ibin, content);
6536 if (errors) {
6537 fSumw2.fArray[ibin] += hold->GetBinErrorSqUnchecked(bin);
6538 }
6539 }
6540 delete hold;
6541}
6542
6543////////////////////////////////////////////////////////////////////////////////
6544/// Recursively remove object from the list of functions
6545
6547{
6548 // Rely on TROOT::RecursiveRemove to take the readlock.
6549
6550 if (fFunctions) {
6552 }
6553}
6554
6555////////////////////////////////////////////////////////////////////////////////
6556/// Multiply this histogram by a constant c1.
6557///
6558/// `this = c1*this`
6559///
6560/// Note that both contents and errors (if any) are scaled.
6561/// This function uses the services of TH1::Add
6562///
6563/// IMPORTANT NOTE: Sumw2() is called automatically when scaling.
6564/// If you are not interested in the histogram statistics you can call
6565/// Sumw2(kFALSE) or use the option "nosw2"
6566///
6567/// One can scale a histogram such that the bins integral is equal to
6568/// the normalization parameter via TH1::Scale(Double_t norm), where norm
6569/// is the desired normalization divided by the integral of the histogram.
6570///
6571/// If option contains "width" the bin contents and errors are divided
6572/// by the bin width.
6573
6575{
6576
6577 TString opt = option; opt.ToLower();
6578 // store bin errors when scaling since cannot anymore be computed as sqrt(N)
6579 if (!opt.Contains("nosw2") && GetSumw2N() == 0) Sumw2();
6580 if (opt.Contains("width")) Add(this, this, c1, -1);
6581 else {
6582 if (fBuffer) BufferEmpty(1);
6583 for(Int_t i = 0; i < fNcells; ++i) UpdateBinContent(i, c1 * RetrieveBinContent(i));
6584 if (fSumw2.fN) for(Int_t i = 0; i < fNcells; ++i) fSumw2.fArray[i] *= (c1 * c1); // update errors
6585 // update global histograms statistics
6586 Double_t s[kNstat] = {0};
6587 GetStats(s);
6588 for (Int_t i=0 ; i < kNstat; i++) {
6589 if (i == 1) s[i] = c1*c1*s[i];
6590 else s[i] = c1*s[i];
6591 }
6592 PutStats(s);
6593 SetMinimum(); SetMaximum(); // minimum and maximum value will be recalculated the next time
6594 }
6595
6596 // if contours set, must also scale contours
6597 Int_t ncontours = GetContour();
6598 if (ncontours == 0) return;
6599 Double_t* levels = fContour.GetArray();
6600 for (Int_t i = 0; i < ncontours; ++i) levels[i] *= c1;
6601}
6602
6603////////////////////////////////////////////////////////////////////////////////
6604/// Returns true if all axes are extendable.
6605
6607{
6608 Bool_t canExtend = fXaxis.CanExtend();
6609 if (GetDimension() > 1) canExtend &= fYaxis.CanExtend();
6610 if (GetDimension() > 2) canExtend &= fZaxis.CanExtend();
6611
6612 return canExtend;
6613}
6614
6615////////////////////////////////////////////////////////////////////////////////
6616/// Make the histogram axes extendable / not extendable according to the bit mask
6617/// returns the previous bit mask specifying which axes are extendable
6618
6619UInt_t TH1::SetCanExtend(UInt_t extendBitMask)
6620{
6621 UInt_t oldExtendBitMask = kNoAxis;
6622
6623 if (fXaxis.CanExtend()) oldExtendBitMask |= kXaxis;
6624 if (extendBitMask & kXaxis) fXaxis.SetCanExtend(kTRUE);
6626
6627 if (GetDimension() > 1) {
6628 if (fYaxis.CanExtend()) oldExtendBitMask |= kYaxis;
6629 if (extendBitMask & kYaxis) fYaxis.SetCanExtend(kTRUE);
6631 }
6632
6633 if (GetDimension() > 2) {
6634 if (fZaxis.CanExtend()) oldExtendBitMask |= kZaxis;
6635 if (extendBitMask & kZaxis) fZaxis.SetCanExtend(kTRUE);
6637 }
6638
6639 return oldExtendBitMask;
6640}
6641
6642///////////////////////////////////////////////////////////////////////////////
6643/// Internal function used in TH1::Fill to see which axis is full alphanumeric,
6644/// i.e. can be extended and is alphanumeric
6646{
6647 UInt_t bitMask = kNoAxis;
6648 if (fXaxis.CanExtend() && fXaxis.IsAlphanumeric() ) bitMask |= kXaxis;
6650 bitMask |= kYaxis;
6652 bitMask |= kZaxis;
6653
6654 return bitMask;
6655}
6656
6657////////////////////////////////////////////////////////////////////////////////
6658/// Static function to set the default buffer size for automatic histograms.
6659/// When a histogram is created with one of its axis lower limit greater
6660/// or equal to its upper limit, the function SetBuffer is automatically
6661/// called with the default buffer size.
6662
6663void TH1::SetDefaultBufferSize(Int_t buffersize)
6664{
6665 fgBufferSize = buffersize > 0 ? buffersize : 0;
6666}
6667
6668////////////////////////////////////////////////////////////////////////////////
6669/// When this static function is called with `sumw2=kTRUE`, all new
6670/// histograms will automatically activate the storage
6671/// of the sum of squares of errors, ie TH1::Sumw2 is automatically called.
6672
6673void TH1::SetDefaultSumw2(Bool_t sumw2)
6674{
6675 fgDefaultSumw2 = sumw2;
6676}
6677
6678////////////////////////////////////////////////////////////////////////////////
6679/// Change/set the title.
6680///
6681/// If title is in the form `stringt;stringx;stringy;stringz`
6682/// the histogram title is set to `stringt`, the x axis title to `stringx`,
6683/// the y axis title to `stringy`, and the z axis title to `stringz`.
6684///
6685/// To insert the character `;` in one of the titles, one should use `#;`
6686/// or `#semicolon`.
6687
6688void TH1::SetTitle(const char *title)
6689{
6690 fTitle = title;
6691 fTitle.ReplaceAll("#;",2,"#semicolon",10);
6692
6693 // Decode fTitle. It may contain X, Y and Z titles
6694 TString str1 = fTitle, str2;
6695 Int_t isc = str1.Index(";");
6696 Int_t lns = str1.Length();
6697
6698 if (isc >=0 ) {
6699 fTitle = str1(0,isc);
6700 str1 = str1(isc+1, lns);
6701 isc = str1.Index(";");
6702 if (isc >=0 ) {
6703 str2 = str1(0,isc);
6704 str2.ReplaceAll("#semicolon",10,";",1);
6705 fXaxis.SetTitle(str2.Data());
6706 lns = str1.Length();
6707 str1 = str1(isc+1, lns);
6708 isc = str1.Index(";");
6709 if (isc >=0 ) {
6710 str2 = str1(0,isc);
6711 str2.ReplaceAll("#semicolon",10,";",1);
6712 fYaxis.SetTitle(str2.Data());
6713 lns = str1.Length();
6714 str1 = str1(isc+1, lns);
6715 str1.ReplaceAll("#semicolon",10,";",1);
6716 fZaxis.SetTitle(str1.Data());
6717 } else {
6718 str1.ReplaceAll("#semicolon",10,";",1);
6719 fYaxis.SetTitle(str1.Data());
6720 }
6721 } else {
6722 str1.ReplaceAll("#semicolon",10,";",1);
6723 fXaxis.SetTitle(str1.Data());
6724 }
6725 }
6726
6727 fTitle.ReplaceAll("#semicolon",10,";",1);
6728
6729 if (gPad && TestBit(kMustCleanup)) gPad->Modified();
6730}
6731
6732////////////////////////////////////////////////////////////////////////////////
6733/// Smooth array xx, translation of Hbook routine `hsmoof.F`.
6734/// Based on algorithm 353QH twice presented by J. Friedman
6735/// in [Proc. of the 1974 CERN School of Computing, Norway, 11-24 August, 1974](https://cds.cern.ch/record/186223).
6736/// See also Section 4.2 in [J. Friedman, Data Analysis Techniques for High Energy Physics](https://www.slac.stanford.edu/pubs/slacreports/reports16/slac-r-176.pdf).
6737
6738void TH1::SmoothArray(Int_t nn, Double_t *xx, Int_t ntimes)
6739{
6740 if (nn < 3 ) {
6741 ::Error("SmoothArray","Need at least 3 points for smoothing: n = %d",nn);
6742 return;
6743 }
6744
6745 Int_t ii;
6746 std::array<double, 3> hh{};
6747
6748 std::vector<double> yy(nn);
6749 std::vector<double> zz(nn);
6750 std::vector<double> rr(nn);
6751
6752 for (Int_t pass=0;pass<ntimes;pass++) {
6753 // first copy original data into temp array
6754 std::copy(xx, xx+nn, zz.begin() );
6755
6756 for (int noent = 0; noent < 2; ++noent) { // run algorithm two times
6757
6758 // do 353 i.e. running median 3, 5, and 3 in a single loop
6759 for (int kk = 0; kk < 3; kk++) {
6760 std::copy(zz.begin(), zz.end(), yy.begin());
6761 int medianType = (kk != 1) ? 3 : 5;
6762 int ifirst = (kk != 1 ) ? 1 : 2;
6763 int ilast = (kk != 1 ) ? nn-1 : nn -2;
6764 //nn2 = nn - ik - 1;
6765 // do all elements beside the first and last point for median 3
6766 // and first two and last 2 for median 5
6767 for ( ii = ifirst; ii < ilast; ii++) {
6768 zz[ii] = TMath::Median(medianType, yy.data() + ii - ifirst);
6769 }
6770
6771 if (kk == 0) { // first median 3
6772 // first point
6773 hh[0] = zz[1];
6774 hh[1] = zz[0];
6775 hh[2] = 3*zz[1] - 2*zz[2];
6776 zz[0] = TMath::Median(3, hh.data());
6777 // last point
6778 hh[0] = zz[nn - 2];
6779 hh[1] = zz[nn - 1];
6780 hh[2] = 3*zz[nn - 2] - 2*zz[nn - 3];
6781 zz[nn - 1] = TMath::Median(3, hh.data());
6782 }
6783
6784 if (kk == 1) { // median 5
6785 // second point with window length 3
6786 zz[1] = TMath::Median(3, yy.data());
6787 // second-to-last point with window length 3
6788 zz[nn - 2] = TMath::Median(3, yy.data() + nn - 3);
6789 }
6790
6791 // In the third iteration (kk == 2), the first and last point stay
6792 // the same (see paper linked in the documentation).
6793 }
6794
6795 std::copy ( zz.begin(), zz.end(), yy.begin() );
6796
6797 // quadratic interpolation for flat segments
6798 for (ii = 2; ii < (nn - 2); ii++) {
6799 if (zz[ii - 1] != zz[ii]) continue;
6800 if (zz[ii] != zz[ii + 1]) continue;
6801 const double tmp0 = zz[ii - 2] - zz[ii];
6802 const double tmp1 = zz[ii + 2] - zz[ii];
6803 if (tmp0 * tmp1 <= 0) continue;
6804 int jk = 1;
6805 if ( std::abs(tmp0) > std::abs(tmp0) ) jk = -1;
6806 yy[ii] = -0.5*zz[ii - 2*jk] + zz[ii]/0.75 + zz[ii + 2*jk] /6.;
6807 yy[ii + jk] = 0.5*(zz[ii + 2*jk] - zz[ii - 2*jk]) + zz[ii];
6808 }
6809
6810 // running means
6811 //std::copy(zz.begin(), zz.end(), yy.begin());
6812 for (ii = 1; ii < nn - 1; ii++) {
6813 zz[ii] = 0.25*yy[ii - 1] + 0.5*yy[ii] + 0.25*yy[ii + 1];
6814 }
6815 zz[0] = yy[0];
6816 zz[nn - 1] = yy[nn - 1];
6817
6818 if (noent == 0) {
6819
6820 // save computed values
6821 std::copy(zz.begin(), zz.end(), rr.begin());
6822
6823 // COMPUTE residuals
6824 for (ii = 0; ii < nn; ii++) {
6825 zz[ii] = xx[ii] - zz[ii];
6826 }
6827 }
6828
6829 } // end loop on noent
6830
6831
6832 double xmin = TMath::MinElement(nn,xx);
6833 for (ii = 0; ii < nn; ii++) {
6834 if (xmin < 0) xx[ii] = rr[ii] + zz[ii];
6835 // make smoothing defined positive - not better using 0 ?
6836 else xx[ii] = std::max((rr[ii] + zz[ii]),0.0 );
6837 }
6838 }
6839}
6840
6841////////////////////////////////////////////////////////////////////////////////
6842/// Smooth bin contents of this histogram.
6843/// if option contains "R" smoothing is applied only to the bins
6844/// defined in the X axis range (default is to smooth all bins)
6845/// Bin contents are replaced by their smooth values.
6846/// Errors (if any) are not modified.
6847/// the smoothing procedure is repeated ntimes (default=1)
6848
6849void TH1::Smooth(Int_t ntimes, Option_t *option)
6850{
6851 if (fDimension != 1) {
6852 Error("Smooth","Smooth only supported for 1-d histograms");
6853 return;
6854 }
6855 Int_t nbins = fXaxis.GetNbins();
6856 if (nbins < 3) {
6857 Error("Smooth","Smooth only supported for histograms with >= 3 bins. Nbins = %d",nbins);
6858 return;
6859 }
6860
6861 // delete buffer if it is there since it will become invalid
6862 if (fBuffer) BufferEmpty(1);
6863
6864 Int_t firstbin = 1, lastbin = nbins;
6865 TString opt = option;
6866 opt.ToLower();
6867 if (opt.Contains("r")) {
6868 firstbin= fXaxis.GetFirst();
6869 lastbin = fXaxis.GetLast();
6870 }
6871 nbins = lastbin - firstbin + 1;
6872 Double_t *xx = new Double_t[nbins];
6873 Double_t nent = fEntries;
6874 Int_t i;
6875 for (i=0;i<nbins;i++) {
6876 xx[i] = RetrieveBinContent(i+firstbin);
6877 }
6878
6879 TH1::SmoothArray(nbins,xx,ntimes);
6880
6881 for (i=0;i<nbins;i++) {
6882 UpdateBinContent(i+firstbin,xx[i]);
6883 }
6884 fEntries = nent;
6885 delete [] xx;
6886
6887 if (gPad) gPad->Modified();
6888}
6889
6890////////////////////////////////////////////////////////////////////////////////
6891/// if flag=kTRUE, underflows and overflows are used by the Fill functions
6892/// in the computation of statistics (mean value, StdDev).
6893/// By default, underflows or overflows are not used.
6894
6895void TH1::StatOverflows(Bool_t flag)
6896{
6897 fgStatOverflows = flag;
6898}
6899
6900////////////////////////////////////////////////////////////////////////////////
6901/// Stream a class object.
6902
6903void TH1::Streamer(TBuffer &b)
6904{
6905 if (b.IsReading()) {
6906 UInt_t R__s, R__c;
6907 Version_t R__v = b.ReadVersion(&R__s, &R__c);
6908 if (fDirectory) fDirectory->Remove(this);
6909 fDirectory = nullptr;
6910 if (R__v > 2) {
6911 b.ReadClassBuffer(TH1::Class(), this, R__v, R__s, R__c);
6912
6914 fXaxis.SetParent(this);
6915 fYaxis.SetParent(this);
6916 fZaxis.SetParent(this);
6917 TIter next(fFunctions);
6918 TObject *obj;
6919 while ((obj=next())) {
6920 if (obj->InheritsFrom(TF1::Class())) ((TF1*)obj)->SetParent(this);
6921 }
6922 return;
6923 }
6924 //process old versions before automatic schema evolution
6929 b >> fNcells;
6930 fXaxis.Streamer(b);
6931 fYaxis.Streamer(b);
6932 fZaxis.Streamer(b);
6933 fXaxis.SetParent(this);
6934 fYaxis.SetParent(this);
6935 fZaxis.SetParent(this);
6936 b >> fBarOffset;
6937 b >> fBarWidth;
6938 b >> fEntries;
6939 b >> fTsumw;
6940 b >> fTsumw2;
6941 b >> fTsumwx;
6942 b >> fTsumwx2;
6943 if (R__v < 2) {
6944 Float_t maximum, minimum, norm;
6945 Float_t *contour=nullptr;
6946 b >> maximum; fMaximum = maximum;
6947 b >> minimum; fMinimum = minimum;
6948 b >> norm; fNormFactor = norm;
6949 Int_t n = b.ReadArray(contour);
6950 fContour.Set(n);
6951 for (Int_t i=0;i<n;i++) fContour.fArray[i] = contour[i];
6952 delete [] contour;
6953 } else {
6954 b >> fMaximum;
6955 b >> fMinimum;
6956 b >> fNormFactor;
6958 }
6959 fSumw2.Streamer(b);
6961 fFunctions->Delete();
6963 b.CheckByteCount(R__s, R__c, TH1::IsA());
6964
6965 } else {
6966 b.WriteClassBuffer(TH1::Class(),this);
6967 }
6968}
6969
6970////////////////////////////////////////////////////////////////////////////////
6971/// Print some global quantities for this histogram.
6972/// \param[in] option
6973/// - "base" is given, number of bins and ranges are also printed
6974/// - "range" is given, bin contents and errors are also printed
6975/// for all bins in the current range (default 1-->nbins)
6976/// - "all" is given, bin contents and errors are also printed
6977/// for all bins including under and overflows.
6978
6979void TH1::Print(Option_t *option) const
6980{
6981 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
6982 printf( "TH1.Print Name = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
6983 TString opt = option;
6984 opt.ToLower();
6985 Int_t all;
6986 if (opt.Contains("all")) all = 0;
6987 else if (opt.Contains("range")) all = 1;
6988 else if (opt.Contains("base")) all = 2;
6989 else return;
6990
6991 Int_t bin, binx, biny, binz;
6992 Int_t firstx=0,lastx=0,firsty=0,lasty=0,firstz=0,lastz=0;
6993 if (all == 0) {
6994 lastx = fXaxis.GetNbins()+1;
6995 if (fDimension > 1) lasty = fYaxis.GetNbins()+1;
6996 if (fDimension > 2) lastz = fZaxis.GetNbins()+1;
6997 } else {
6998 firstx = fXaxis.GetFirst(); lastx = fXaxis.GetLast();
6999 if (fDimension > 1) {firsty = fYaxis.GetFirst(); lasty = fYaxis.GetLast();}
7000 if (fDimension > 2) {firstz = fZaxis.GetFirst(); lastz = fZaxis.GetLast();}
7001 }
7002
7003 if (all== 2) {
7004 printf(" Title = %s\n", GetTitle());
7005 printf(" NbinsX= %d, xmin= %g, xmax=%g", fXaxis.GetNbins(), fXaxis.GetXmin(), fXaxis.GetXmax());
7006 if( fDimension > 1) printf(", NbinsY= %d, ymin= %g, ymax=%g", fYaxis.GetNbins(), fYaxis.GetXmin(), fYaxis.GetXmax());
7007 if( fDimension > 2) printf(", NbinsZ= %d, zmin= %g, zmax=%g", fZaxis.GetNbins(), fZaxis.GetXmin(), fZaxis.GetXmax());
7008 printf("\n");
7009 return;
7010 }
7011
7012 Double_t w,e;
7013 Double_t x,y,z;
7014 if (fDimension == 1) {
7015 for (binx=firstx;binx<=lastx;binx++) {
7016 x = fXaxis.GetBinCenter(binx);
7017 w = RetrieveBinContent(binx);
7018 e = GetBinError(binx);
7019 if(fSumw2.fN) printf(" fSumw[%d]=%g, x=%g, error=%g\n",binx,w,x,e);
7020 else printf(" fSumw[%d]=%g, x=%g\n",binx,w,x);
7021 }
7022 }
7023 if (fDimension == 2) {
7024 for (biny=firsty;biny<=lasty;biny++) {
7025 y = fYaxis.GetBinCenter(biny);
7026 for (binx=firstx;binx<=lastx;binx++) {
7027 bin = GetBin(binx,biny);
7028 x = fXaxis.GetBinCenter(binx);
7029 w = RetrieveBinContent(bin);
7030 e = GetBinError(bin);
7031 if(fSumw2.fN) printf(" fSumw[%d][%d]=%g, x=%g, y=%g, error=%g\n",binx,biny,w,x,y,e);
7032 else printf(" fSumw[%d][%d]=%g, x=%g, y=%g\n",binx,biny,w,x,y);
7033 }
7034 }
7035 }
7036 if (fDimension == 3) {
7037 for (binz=firstz;binz<=lastz;binz++) {
7038 z = fZaxis.GetBinCenter(binz);
7039 for (biny=firsty;biny<=lasty;biny++) {
7040 y = fYaxis.GetBinCenter(biny);
7041 for (binx=firstx;binx<=lastx;binx++) {
7042 bin = GetBin(binx,biny,binz);
7043 x = fXaxis.GetBinCenter(binx);
7044 w = RetrieveBinContent(bin);
7045 e = GetBinError(bin);
7046 if(fSumw2.fN) printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g, error=%g\n",binx,biny,binz,w,x,y,z,e);
7047 else printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g\n",binx,biny,binz,w,x,y,z);
7048 }
7049 }
7050 }
7051 }
7052}
7053
7054////////////////////////////////////////////////////////////////////////////////
7055/// Using the current bin info, recompute the arrays for contents and errors
7056
7057void TH1::Rebuild(Option_t *)
7058{
7059 SetBinsLength();
7060 if (fSumw2.fN) {
7062 }
7063}
7064
7065////////////////////////////////////////////////////////////////////////////////
7066/// Reset this histogram: contents, errors, etc.
7067/// \param[in] option
7068/// - if "ICE" is specified, resets only Integral, Contents and Errors.
7069/// - if "ICES" is specified, resets only Integral, Contents, Errors and Statistics
7070/// This option is used
7071/// - if "M" is specified, resets also Minimum and Maximum
7072
7074{
7075 // The option "ICE" is used when extending the histogram (in ExtendAxis, LabelInflate, etc..)
7076 // The option "ICES is used in combination with the buffer (see BufferEmpty and BufferFill)
7077
7078 TString opt = option;
7079 opt.ToUpper();
7080 fSumw2.Reset();
7081 if (fIntegral) {
7082 delete [] fIntegral;
7083 fIntegral = nullptr;
7084 }
7085
7086 if (opt.Contains("M")) {
7087 SetMinimum();
7088 SetMaximum();
7089 }
7090
7091 if (opt.Contains("ICE") && !opt.Contains("S")) return;
7092
7093 // Setting fBuffer[0] = 0 is like resetting the buffer but not deleting it
7094 // But what is the sense of calling BufferEmpty() ? For making the axes ?
7095 // BufferEmpty will update contents that later will be
7096 // reset in calling TH1D::Reset. For this we need to reset the stats afterwards
7097 // It may be needed for computing the axis limits....
7098 if (fBuffer) {BufferEmpty(); fBuffer[0] = 0;}
7099
7100 // need to reset also the statistics
7101 // (needs to be done after calling BufferEmpty() )
7102 fTsumw = 0;
7103 fTsumw2 = 0;
7104 fTsumwx = 0;
7105 fTsumwx2 = 0;
7106 fEntries = 0;
7107
7108 if (opt == "ICES") return;
7109
7110
7111 TObject *stats = fFunctions->FindObject("stats");
7112 fFunctions->Remove(stats);
7113 //special logic to support the case where the same object is
7114 //added multiple times in fFunctions.
7115 //This case happens when the same object is added with different
7116 //drawing modes
7117 TObject *obj;
7118 while ((obj = fFunctions->First())) {
7119 while(fFunctions->Remove(obj)) { }
7120 delete obj;
7121 }
7122 if(stats) fFunctions->Add(stats);
7123 fContour.Set(0);
7124}
7125
7126////////////////////////////////////////////////////////////////////////////////
7127/// Save the histogram as .csv, .tsv or .txt. In case of any other extension, fall
7128/// back to TObject::SaveAs, which saves as a .C macro (but with the file name
7129/// extension specified by the user)
7130///
7131/// The Under/Overflow bins are also exported (as first and last lines)
7132/// The fist 2 columns are the lower and upper edges of the bins
7133/// Column 3 contains the bin contents
7134/// The last column contains the error in y. If errors are not present, the column
7135/// is left empty
7136///
7137/// The result can be immediately imported into Excel, gnuplot, Python or whatever,
7138/// without the needing to install pyroot, etc.
7139///
7140/// \param filename the name of the file where to store the histogram
7141/// \param option some tuning options
7142///
7143/// The file extension defines the delimiter used:
7144/// - `.csv` : comma
7145/// - `.tsv` : tab
7146/// - `.txt` : space
7147///
7148/// If option = "title" a title line is generated. If the y-axis has a title,
7149/// this title is displayed as column 3 name, otherwise, it shows "BinContent"
7150
7151void TH1::SaveAs(const char *filename, Option_t *option) const
7152{
7153 char del = '\0';
7154 TString ext = "";
7155 TString fname = filename;
7156 TString opt = option;
7157
7158 if (filename) {
7159 if (fname.EndsWith(".csv")) {
7160 del = ',';
7161 ext = "csv";
7162 } else if (fname.EndsWith(".tsv")) {
7163 del = '\t';
7164 ext = "tsv";
7165 } else if (fname.EndsWith(".txt")) {
7166 del = ' ';
7167 ext = "txt";
7168 }
7169 }
7170 if (!del) {
7172 return;
7173 }
7174 std::ofstream out;
7175 out.open(filename, std::ios::out);
7176 if (!out.good()) {
7177 Error("SaveAs", "cannot open file: %s", filename);
7178 return;
7179 }
7180 if (opt.Contains("title")) {
7181 if (std::strcmp(GetYaxis()->GetTitle(), "") == 0) {
7182 out << "#\tBinLowEdge\tBinUpEdge\t"
7183 << "BinContent"
7184 << "\tey" << std::endl;
7185 } else {
7186 out << "#\tBinLowEdge\tBinUpEdge\t" << GetYaxis()->GetTitle() << "\tey" << std::endl;
7187 }
7188 }
7189 if (fSumw2.fN) {
7190 for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
7191 out << GetXaxis()->GetBinLowEdge(i) << del << GetXaxis()->GetBinUpEdge(i) << del << GetBinContent(i) << del
7192 << GetBinError(i) << std::endl;
7193 }
7194 } else {
7195 for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
7196 out << GetXaxis()->GetBinLowEdge(i) << del << GetXaxis()->GetBinUpEdge(i) << del << GetBinContent(i) << del
7197 << std::endl;
7198 }
7199 }
7200 out.close();
7201 Info("SaveAs", "%s file: %s has been generated", ext.Data(), filename);
7202}
7203
7204////////////////////////////////////////////////////////////////////////////////
7205/// Save primitive as a C++ statement(s) on output stream out
7206
7207void TH1::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
7208{
7209 // empty the buffer before if it exists
7210 if (fBuffer) BufferEmpty();
7211
7212 Bool_t nonEqiX = kFALSE;
7213 Bool_t nonEqiY = kFALSE;
7214 Bool_t nonEqiZ = kFALSE;
7215 Int_t i;
7216 static Int_t nxaxis = 0;
7217 static Int_t nyaxis = 0;
7218 static Int_t nzaxis = 0;
7219 TString sxaxis="xAxis",syaxis="yAxis",szaxis="zAxis";
7220
7221 // Check if the histogram has equidistant X bins or not. If not, we
7222 // create an array holding the bins.
7223 if (GetXaxis()->GetXbins()->fN && GetXaxis()->GetXbins()->fArray) {
7224 nonEqiX = kTRUE;
7225 nxaxis++;
7226 sxaxis += nxaxis;
7227 out << " Double_t "<<sxaxis<<"[" << GetXaxis()->GetXbins()->fN
7228 << "] = {";
7229 for (i = 0; i < GetXaxis()->GetXbins()->fN; i++) {
7230 if (i != 0) out << ", ";
7231 out << GetXaxis()->GetXbins()->fArray[i];
7232 }
7233 out << "}; " << std::endl;
7234 }
7235 // If the histogram is 2 or 3 dimensional, check if the histogram
7236 // has equidistant Y bins or not. If not, we create an array
7237 // holding the bins.
7238 if (fDimension > 1 && GetYaxis()->GetXbins()->fN &&
7239 GetYaxis()->GetXbins()->fArray) {
7240 nonEqiY = kTRUE;
7241 nyaxis++;
7242 syaxis += nyaxis;
7243 out << " Double_t "<<syaxis<<"[" << GetYaxis()->GetXbins()->fN
7244 << "] = {";
7245 for (i = 0; i < GetYaxis()->GetXbins()->fN; i++) {
7246 if (i != 0) out << ", ";
7247 out << GetYaxis()->GetXbins()->fArray[i];
7248 }
7249 out << "}; " << std::endl;
7250 }
7251 // IF the histogram is 3 dimensional, check if the histogram
7252 // has equidistant Z bins or not. If not, we create an array
7253 // holding the bins.
7254 if (fDimension > 2 && GetZaxis()->GetXbins()->fN &&
7255 GetZaxis()->GetXbins()->fArray) {
7256 nonEqiZ = kTRUE;
7257 nzaxis++;
7258 szaxis += nzaxis;
7259 out << " Double_t "<<szaxis<<"[" << GetZaxis()->GetXbins()->fN
7260 << "] = {";
7261 for (i = 0; i < GetZaxis()->GetXbins()->fN; i++) {
7262 if (i != 0) out << ", ";
7263 out << GetZaxis()->GetXbins()->fArray[i];
7264 }
7265 out << "}; " << std::endl;
7266 }
7267
7268 char quote = '"';
7269 out <<" "<<std::endl;
7270 out <<" "<< ClassName() <<" *";
7271
7272 // Histogram pointer has by default the histogram name with an incremental suffix.
7273 // If the histogram belongs to a graph or a stack the suffix is not added because
7274 // the graph and stack objects are not aware of this new name. Same thing if
7275 // the histogram is drawn with the option COLZ because the TPaletteAxis drawn
7276 // when this option is selected, does not know this new name either.
7277 TString opt = option;
7278 opt.ToLower();
7279 static Int_t hcounter = 0;
7280 TString histName = GetName();
7281 if ( !histName.Contains("Graph")
7282 && !histName.Contains("_stack_")
7283 && !opt.Contains("colz")) {
7284 hcounter++;
7285 histName += "__";
7286 histName += hcounter;
7287 }
7288 histName = gInterpreter-> MapCppName(histName);
7289 const char *hname = histName.Data();
7290 if (!strlen(hname)) hname = "unnamed";
7291 TString savedName = GetName();
7292 this->SetName(hname);
7293 TString t(GetTitle());
7294 t.ReplaceAll("\\","\\\\");
7295 t.ReplaceAll("\"","\\\"");
7296 out << hname << " = new " << ClassName() << "(" << quote
7297 << hname << quote << "," << quote<< t.Data() << quote
7298 << "," << GetXaxis()->GetNbins();
7299 if (nonEqiX)
7300 out << ", "<<sxaxis;
7301 else
7302 out << "," << GetXaxis()->GetXmin()
7303 << "," << GetXaxis()->GetXmax();
7304 if (fDimension > 1) {
7305 out << "," << GetYaxis()->GetNbins();
7306 if (nonEqiY)
7307 out << ", "<<syaxis;
7308 else
7309 out << "," << GetYaxis()->GetXmin()
7310 << "," << GetYaxis()->GetXmax();
7311 }
7312 if (fDimension > 2) {
7313 out << "," << GetZaxis()->GetNbins();
7314 if (nonEqiZ)
7315 out << ", "<<szaxis;
7316 else
7317 out << "," << GetZaxis()->GetXmin()
7318 << "," << GetZaxis()->GetXmax();
7319 }
7320 out << ");" << std::endl;
7321
7322 // save bin contents
7323 Int_t bin;
7324 for (bin=0;bin<fNcells;bin++) {
7325 Double_t bc = RetrieveBinContent(bin);
7326 if (bc) {
7327 out<<" "<<hname<<"->SetBinContent("<<bin<<","<<bc<<");"<<std::endl;
7328 }
7329 }
7330
7331 // save bin errors
7332 if (fSumw2.fN) {
7333 for (bin=0;bin<fNcells;bin++) {
7334 Double_t be = GetBinError(bin);
7335 if (be) {
7336 out<<" "<<hname<<"->SetBinError("<<bin<<","<<be<<");"<<std::endl;
7337 }
7338 }
7339 }
7340
7341 TH1::SavePrimitiveHelp(out, hname, option);
7342 this->SetName(savedName.Data());
7343}
7344
7345////////////////////////////////////////////////////////////////////////////////
7346/// Helper function for the SavePrimitive functions from TH1
7347/// or classes derived from TH1, eg TProfile, TProfile2D.
7348
7349void TH1::SavePrimitiveHelp(std::ostream &out, const char *hname, Option_t *option /*= ""*/)
7350{
7351 char quote = '"';
7352 if (TMath::Abs(GetBarOffset()) > 1e-5) {
7353 out<<" "<<hname<<"->SetBarOffset("<<GetBarOffset()<<");"<<std::endl;
7354 }
7355 if (TMath::Abs(GetBarWidth()-1) > 1e-5) {
7356 out<<" "<<hname<<"->SetBarWidth("<<GetBarWidth()<<");"<<std::endl;
7357 }
7358 if (fMinimum != -1111) {
7359 out<<" "<<hname<<"->SetMinimum("<<fMinimum<<");"<<std::endl;
7360 }
7361 if (fMaximum != -1111) {
7362 out<<" "<<hname<<"->SetMaximum("<<fMaximum<<");"<<std::endl;
7363 }
7364 if (fNormFactor != 0) {
7365 out<<" "<<hname<<"->SetNormFactor("<<fNormFactor<<");"<<std::endl;
7366 }
7367 if (fEntries != 0) {
7368 out<<" "<<hname<<"->SetEntries("<<fEntries<<");"<<std::endl;
7369 }
7370 if (!fDirectory) {
7371 out<<" "<<hname<<"->SetDirectory(nullptr);"<<std::endl;
7372 }
7373 if (TestBit(kNoStats)) {
7374 out<<" "<<hname<<"->SetStats(0);"<<std::endl;
7375 }
7376 if (fOption.Length() != 0) {
7377 out<<" "<<hname<<"->SetOption("<<quote<<fOption.Data()<<quote<<");"<<std::endl;
7378 }
7379
7380 // save contour levels
7381 Int_t ncontours = GetContour();
7382 if (ncontours > 0) {
7383 out<<" "<<hname<<"->SetContour("<<ncontours<<");"<<std::endl;
7384 Double_t zlevel;
7385 for (Int_t bin=0;bin<ncontours;bin++) {
7386 if (gPad->GetLogz()) {
7387 zlevel = TMath::Power(10,GetContourLevel(bin));
7388 } else {
7389 zlevel = GetContourLevel(bin);
7390 }
7391 out<<" "<<hname<<"->SetContourLevel("<<bin<<","<<zlevel<<");"<<std::endl;
7392 }
7393 }
7394
7395 // save list of functions
7396 auto lnk = fFunctions->FirstLink();
7397 static Int_t funcNumber = 0;
7398 while (lnk) {
7399 auto obj = lnk->GetObject();
7400 obj->SavePrimitive(out, TString::Format("nodraw #%d\n",++funcNumber).Data());
7401 if (obj->InheritsFrom(TF1::Class())) {
7402 TString fname;
7403 fname.Form("%s%d",obj->GetName(),funcNumber);
7404 out << " " << fname << "->SetParent(" << hname << ");\n";
7405 out<<" "<<hname<<"->GetListOfFunctions()->Add("
7406 << fname <<");"<<std::endl;
7407 } else if (obj->InheritsFrom("TPaveStats")) {
7408 out<<" "<<hname<<"->GetListOfFunctions()->Add(ptstats);"<<std::endl;
7409 out<<" ptstats->SetParent("<<hname<<");"<<std::endl;
7410 } else if (obj->InheritsFrom("TPolyMarker")) {
7411 out<<" "<<hname<<"->GetListOfFunctions()->Add("
7412 <<"pmarker ,"<<quote<<lnk->GetOption()<<quote<<");"<<std::endl;
7413 } else {
7414 out<<" "<<hname<<"->GetListOfFunctions()->Add("
7415 <<obj->GetName()
7416 <<","<<quote<<lnk->GetOption()<<quote<<");"<<std::endl;
7417 }
7418 lnk = lnk->Next();
7419 }
7420
7421 // save attributes
7422 SaveFillAttributes(out,hname,0,1001);
7423 SaveLineAttributes(out,hname,1,1,1);
7424 SaveMarkerAttributes(out,hname,1,1,1);
7425 fXaxis.SaveAttributes(out,hname,"->GetXaxis()");
7426 fYaxis.SaveAttributes(out,hname,"->GetYaxis()");
7427 fZaxis.SaveAttributes(out,hname,"->GetZaxis()");
7428 TString opt = option;
7429 opt.ToLower();
7430 if (!opt.Contains("nodraw")) {
7431 out<<" "<<hname<<"->Draw("
7432 <<quote<<option<<quote<<");"<<std::endl;
7433 }
7434}
7435
7436////////////////////////////////////////////////////////////////////////////////
7437/// Copy current attributes from/to current style
7438
7440{
7441 if (!gStyle) return;
7442 if (gStyle->IsReading()) {
7443 fXaxis.ResetAttAxis("X");
7444 fYaxis.ResetAttAxis("Y");
7445 fZaxis.ResetAttAxis("Z");
7456 Int_t dostat = gStyle->GetOptStat();
7457 if (gStyle->GetOptFit() && !dostat) dostat = 1000000001;
7458 SetStats(dostat);
7459 } else {
7471 }
7472 TIter next(GetListOfFunctions());
7473 TObject *obj;
7474
7475 while ((obj = next())) {
7476 obj->UseCurrentStyle();
7477 }
7478}
7479
7480////////////////////////////////////////////////////////////////////////////////
7481/// For axis = 1,2 or 3 returns the mean value of the histogram along
7482/// X,Y or Z axis.
7483///
7484/// For axis = 11, 12, 13 returns the standard error of the mean value
7485/// of the histogram along X, Y or Z axis
7486///
7487/// Note that the mean value/StdDev is computed using the bins in the currently
7488/// defined range (see TAxis::SetRange). By default the range includes
7489/// all bins from 1 to nbins included, excluding underflows and overflows.
7490/// To force the underflows and overflows in the computation, one must
7491/// call the static function TH1::StatOverflows(kTRUE) before filling
7492/// the histogram.
7493///
7494/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7495/// are calculated. By default, if no range has been set, the returned mean is
7496/// the (unbinned) one calculated at fill time. If a range has been set, however,
7497/// the mean is calculated using the bins in range, as described above; THIS
7498/// IS TRUE EVEN IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset
7499/// the range. To ensure that the returned mean (and all other statistics) is
7500/// always that of the binned data stored in the histogram, call TH1::ResetStats.
7501/// See TH1::GetStats.
7502///
7503/// Return mean value of this histogram along the X axis.
7504
7505Double_t TH1::GetMean(Int_t axis) const
7506{
7507 if (axis<1 || (axis>3 && axis<11) || axis>13) return 0;
7508 Double_t stats[kNstat];
7509 for (Int_t i=4;i<kNstat;i++) stats[i] = 0;
7510 GetStats(stats);
7511 if (stats[0] == 0) return 0;
7512 if (axis<4){
7513 Int_t ax[3] = {2,4,7};
7514 return stats[ax[axis-1]]/stats[0];
7515 } else {
7516 // mean error = StdDev / sqrt( Neff )
7517 Double_t stddev = GetStdDev(axis-10);
7519 return ( neff > 0 ? stddev/TMath::Sqrt(neff) : 0. );
7520 }
7521}
7522
7523////////////////////////////////////////////////////////////////////////////////
7524/// Return standard error of mean of this histogram along the X axis.
7525///
7526/// Note that the mean value/StdDev is computed using the bins in the currently
7527/// defined range (see TAxis::SetRange). By default the range includes
7528/// all bins from 1 to nbins included, excluding underflows and overflows.
7529/// To force the underflows and overflows in the computation, one must
7530/// call the static function TH1::StatOverflows(kTRUE) before filling
7531/// the histogram.
7532///
7533/// Also note, that although the definition of standard error doesn't include the
7534/// assumption of normality, many uses of this feature implicitly assume it.
7535///
7536/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7537/// are calculated. By default, if no range has been set, the returned value is
7538/// the (unbinned) one calculated at fill time. If a range has been set, however,
7539/// the value is calculated using the bins in range, as described above; THIS
7540/// IS TRUE EVEN IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset
7541/// the range. To ensure that the returned value (and all other statistics) is
7542/// always that of the binned data stored in the histogram, call TH1::ResetStats.
7543/// See TH1::GetStats.
7544
7546{
7547 return GetMean(axis+10);
7548}
7549
7550////////////////////////////////////////////////////////////////////////////////
7551/// Returns the Standard Deviation (Sigma).
7552/// The Sigma estimate is computed as
7553/// \f[
7554/// \sqrt{\frac{1}{N}(\sum(x_i-x_{mean})^2)}
7555/// \f]
7556/// For axis = 1,2 or 3 returns the Sigma value of the histogram along
7557/// X, Y or Z axis
7558/// For axis = 11, 12 or 13 returns the error of StdDev estimation along
7559/// X, Y or Z axis for Normal distribution
7560///
7561/// Note that the mean value/sigma is computed using the bins in the currently
7562/// defined range (see TAxis::SetRange). By default the range includes
7563/// all bins from 1 to nbins included, excluding underflows and overflows.
7564/// To force the underflows and overflows in the computation, one must
7565/// call the static function TH1::StatOverflows(kTRUE) before filling
7566/// the histogram.
7567///
7568/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7569/// are calculated. By default, if no range has been set, the returned standard
7570/// deviation is the (unbinned) one calculated at fill time. If a range has been
7571/// set, however, the standard deviation is calculated using the bins in range,
7572/// as described above; THIS IS TRUE EVEN IF THE RANGE INCLUDES ALL BINS--use
7573/// TAxis::SetRange(0, 0) to unset the range. To ensure that the returned standard
7574/// deviation (and all other statistics) is always that of the binned data stored
7575/// in the histogram, call TH1::ResetStats. See TH1::GetStats.
7576
7577Double_t TH1::GetStdDev(Int_t axis) const
7578{
7579 if (axis<1 || (axis>3 && axis<11) || axis>13) return 0;
7580
7581 Double_t x, stddev2, stats[kNstat];
7582 for (Int_t i=4;i<kNstat;i++) stats[i] = 0;
7583 GetStats(stats);
7584 if (stats[0] == 0) return 0;
7585 Int_t ax[3] = {2,4,7};
7586 Int_t axm = ax[axis%10 - 1];
7587 x = stats[axm]/stats[0];
7588 // for negative stddev (e.g. when having negative weights) - return stdev=0
7589 stddev2 = TMath::Max( stats[axm+1]/stats[0] -x*x, 0.0 );
7590 if (axis<10)
7591 return TMath::Sqrt(stddev2);
7592 else {
7593 // The right formula for StdDev error depends on 4th momentum (see Kendall-Stuart Vol 1 pag 243)
7594 // formula valid for only gaussian distribution ( 4-th momentum = 3 * sigma^4 )
7596 return ( neff > 0 ? TMath::Sqrt(stddev2/(2*neff) ) : 0. );
7597 }
7598}
7599
7600////////////////////////////////////////////////////////////////////////////////
7601/// Return error of standard deviation estimation for Normal distribution
7602///
7603/// Note that the mean value/StdDev is computed using the bins in the currently
7604/// defined range (see TAxis::SetRange). By default the range includes
7605/// all bins from 1 to nbins included, excluding underflows and overflows.
7606/// To force the underflows and overflows in the computation, one must
7607/// call the static function TH1::StatOverflows(kTRUE) before filling
7608/// the histogram.
7609///
7610/// Value returned is standard deviation of sample standard deviation.
7611/// Note that it is an approximated value which is valid only in the case that the
7612/// original data distribution is Normal. The correct one would require
7613/// the 4-th momentum value, which cannot be accurately estimated from a histogram since
7614/// the x-information for all entries is not kept.
7615///
7616/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7617/// are calculated. By default, if no range has been set, the returned value is
7618/// the (unbinned) one calculated at fill time. If a range has been set, however,
7619/// the value is calculated using the bins in range, as described above; THIS
7620/// IS TRUE EVEN IF THE RANGE INCLUDES ALL BINS--use TAxis::SetRange(0, 0) to unset
7621/// the range. To ensure that the returned value (and all other statistics) is
7622/// always that of the binned data stored in the histogram, call TH1::ResetStats.
7623/// See TH1::GetStats.
7624
7626{
7627 return GetStdDev(axis+10);
7628}
7629
7630////////////////////////////////////////////////////////////////////////////////
7631/// - For axis = 1, 2 or 3 returns skewness of the histogram along x, y or z axis.
7632/// - For axis = 11, 12 or 13 returns the approximate standard error of skewness
7633/// of the histogram along x, y or z axis
7634///
7635///Note, that since third and fourth moment are not calculated
7636///at the fill time, skewness and its standard error are computed bin by bin
7637///
7638/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7639/// are calculated. See TH1::GetMean and TH1::GetStdDev.
7640
7642{
7643
7644 if (axis > 0 && axis <= 3){
7645
7646 Double_t mean = GetMean(axis);
7647 Double_t stddev = GetStdDev(axis);
7648 Double_t stddev3 = stddev*stddev*stddev;
7649
7650 Int_t firstBinX = fXaxis.GetFirst();
7651 Int_t lastBinX = fXaxis.GetLast();
7652 Int_t firstBinY = fYaxis.GetFirst();
7653 Int_t lastBinY = fYaxis.GetLast();
7654 Int_t firstBinZ = fZaxis.GetFirst();
7655 Int_t lastBinZ = fZaxis.GetLast();
7656 // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
7659 if (firstBinX == 1) firstBinX = 0;
7660 if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1;
7661 }
7663 if (firstBinY == 1) firstBinY = 0;
7664 if (lastBinY == fYaxis.GetNbins() ) lastBinY += 1;
7665 }
7667 if (firstBinZ == 1) firstBinZ = 0;
7668 if (lastBinZ == fZaxis.GetNbins() ) lastBinZ += 1;
7669 }
7670 }
7671
7672 Double_t x = 0;
7673 Double_t sum=0;
7674 Double_t np=0;
7675 for (Int_t binx = firstBinX; binx <= lastBinX; binx++) {
7676 for (Int_t biny = firstBinY; biny <= lastBinY; biny++) {
7677 for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) {
7678 if (axis==1 ) x = fXaxis.GetBinCenter(binx);
7679 else if (axis==2 ) x = fYaxis.GetBinCenter(biny);
7680 else if (axis==3 ) x = fZaxis.GetBinCenter(binz);
7681 Double_t w = GetBinContent(binx,biny,binz);
7682 np+=w;
7683 sum+=w*(x-mean)*(x-mean)*(x-mean);
7684 }
7685 }
7686 }
7687 sum/=np*stddev3;
7688 return sum;
7689 }
7690 else if (axis > 10 && axis <= 13) {
7691 //compute standard error of skewness
7692 // assume parent normal distribution use formula from Kendall-Stuart, Vol 1 pag 243, second edition
7694 return ( neff > 0 ? TMath::Sqrt(6./neff ) : 0. );
7695 }
7696 else {
7697 Error("GetSkewness", "illegal value of parameter");
7698 return 0;
7699 }
7700}
7701
7702////////////////////////////////////////////////////////////////////////////////
7703/// - For axis =1, 2 or 3 returns kurtosis of the histogram along x, y or z axis.
7704/// Kurtosis(gaussian(0, 1)) = 0.
7705/// - For axis =11, 12 or 13 returns the approximate standard error of kurtosis
7706/// of the histogram along x, y or z axis
7707////
7708/// Note, that since third and fourth moment are not calculated
7709/// at the fill time, kurtosis and its standard error are computed bin by bin
7710///
7711/// IMPORTANT NOTE: The returned value depends on how the histogram statistics
7712/// are calculated. See TH1::GetMean and TH1::GetStdDev.
7713
7715{
7716 if (axis > 0 && axis <= 3){
7717
7718 Double_t mean = GetMean(axis);
7719 Double_t stddev = GetStdDev(axis);
7720 Double_t stddev4 = stddev*stddev*stddev*stddev;
7721
7722 Int_t firstBinX = fXaxis.GetFirst();
7723 Int_t lastBinX = fXaxis.GetLast();
7724 Int_t firstBinY = fYaxis.GetFirst();
7725 Int_t lastBinY = fYaxis.GetLast();
7726 Int_t firstBinZ = fZaxis.GetFirst();
7727 Int_t lastBinZ = fZaxis.GetLast();
7728 // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
7731 if (firstBinX == 1) firstBinX = 0;
7732 if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1;
7733 }
7735 if (firstBinY == 1) firstBinY = 0;
7736 if (lastBinY == fYaxis.GetNbins() ) lastBinY += 1;
7737 }
7739 if (firstBinZ == 1) firstBinZ = 0;
7740 if (lastBinZ == fZaxis.GetNbins() ) lastBinZ += 1;
7741 }
7742 }
7743
7744 Double_t x = 0;
7745 Double_t sum=0;
7746 Double_t np=0;
7747 for (Int_t binx = firstBinX; binx <= lastBinX; binx++) {
7748 for (Int_t biny = firstBinY; biny <= lastBinY; biny++) {
7749 for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) {
7750 if (axis==1 ) x = fXaxis.GetBinCenter(binx);
7751 else if (axis==2 ) x = fYaxis.GetBinCenter(biny);
7752 else if (axis==3 ) x = fZaxis.GetBinCenter(binz);
7753 Double_t w = GetBinContent(binx,biny,binz);
7754 np+=w;
7755 sum+=w*(x-mean)*(x-mean)*(x-mean)*(x-mean);
7756 }
7757 }
7758 }
7759 sum/=(np*stddev4);
7760 return sum-3;
7761
7762 } else if (axis > 10 && axis <= 13) {
7763 //compute standard error of skewness
7764 // assume parent normal distribution use formula from Kendall-Stuart, Vol 1 pag 243, second edition
7766 return ( neff > 0 ? TMath::Sqrt(24./neff ) : 0. );
7767 }
7768 else {
7769 Error("GetKurtosis", "illegal value of parameter");
7770 return 0;
7771 }
7772}
7773
7774////////////////////////////////////////////////////////////////////////////////
7775/// fill the array stats from the contents of this histogram
7776/// The array stats must be correctly dimensioned in the calling program.
7777///
7778/// ~~~ {.cpp}
7779/// stats[0] = sumw
7780/// stats[1] = sumw2
7781/// stats[2] = sumwx
7782/// stats[3] = sumwx2
7783/// ~~~
7784///
7785/// If no axis-subrange is specified (via TAxis::SetRange), the array stats
7786/// is simply a copy of the statistics quantities computed at filling time.
7787/// If a sub-range is specified, the function recomputes these quantities
7788/// from the bin contents in the current axis range.
7789///
7790/// IMPORTANT NOTE: This means that the returned statistics are context-dependent.
7791/// If TAxis::kAxisRange, the returned statistics are dependent on the binning;
7792/// otherwise, they are a copy of the histogram statistics computed at fill time,
7793/// which are unbinned by default (calling TH1::ResetStats forces them to use
7794/// binned statistics). You can reset TAxis::kAxisRange using TAxis::SetRange(0, 0).
7795///
7796/// Note that the mean value/StdDev is computed using the bins in the currently
7797/// defined range (see TAxis::SetRange). By default the range includes
7798/// all bins from 1 to nbins included, excluding underflows and overflows.
7799/// To force the underflows and overflows in the computation, one must
7800/// call the static function TH1::StatOverflows(kTRUE) before filling
7801/// the histogram.
7802
7803void TH1::GetStats(Double_t *stats) const
7804{
7805 if (fBuffer) ((TH1*)this)->BufferEmpty();
7806
7807 // Loop on bins (possibly including underflows/overflows)
7808 Int_t bin, binx;
7809 Double_t w,err;
7810 Double_t x;
7811 // identify the case of labels with extension of axis range
7812 // in this case the statistics in x does not make any sense
7813 Bool_t labelHist = ((const_cast<TAxis&>(fXaxis)).GetLabels() && fXaxis.CanExtend() );
7814 // fTsumw == 0 && fEntries > 0 is a special case when uses SetBinContent or calls ResetStats before
7815 if ( (fTsumw == 0 && fEntries > 0) || fXaxis.TestBit(TAxis::kAxisRange) ) {
7816 for (bin=0;bin<4;bin++) stats[bin] = 0;
7817
7818 Int_t firstBinX = fXaxis.GetFirst();
7819 Int_t lastBinX = fXaxis.GetLast();
7820 // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
7822 if (firstBinX == 1) firstBinX = 0;
7823 if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1;
7824 }
7825 for (binx = firstBinX; binx <= lastBinX; binx++) {
7826 x = fXaxis.GetBinCenter(binx);
7827 //w = TMath::Abs(RetrieveBinContent(binx));
7828 // not sure what to do here if w < 0
7829 w = RetrieveBinContent(binx);
7830 err = TMath::Abs(GetBinError(binx));
7831 stats[0] += w;
7832 stats[1] += err*err;
7833 // statistics in x makes sense only for not labels histograms
7834 if (!labelHist) {
7835 stats[2] += w*x;
7836 stats[3] += w*x*x;
7837 }
7838 }
7839 // if (stats[0] < 0) {
7840 // // in case total is negative do something ??
7841 // stats[0] = 0;
7842 // }
7843 } else {
7844 stats[0] = fTsumw;
7845 stats[1] = fTsumw2;
7846 stats[2] = fTsumwx;
7847 stats[3] = fTsumwx2;
7848 }
7849}
7850
7851////////////////////////////////////////////////////////////////////////////////
7852/// Replace current statistics with the values in array stats
7853
7854void TH1::PutStats(Double_t *stats)
7855{
7856 fTsumw = stats[0];
7857 fTsumw2 = stats[1];
7858 fTsumwx = stats[2];
7859 fTsumwx2 = stats[3];
7860}
7861
7862////////////////////////////////////////////////////////////////////////////////
7863/// Reset the statistics including the number of entries
7864/// and replace with values calculated from bin content
7865///
7866/// The number of entries is set to the total bin content or (in case of weighted histogram)
7867/// to number of effective entries
7868///
7869/// Note that, by default, before calling this function, statistics are those
7870/// computed at fill time, which are unbinned. See TH1::GetStats.
7871
7872void TH1::ResetStats()
7873{
7874 Double_t stats[kNstat] = {0};
7875 fTsumw = 0;
7876 fEntries = 1; // to force re-calculation of the statistics in TH1::GetStats
7877 GetStats(stats);
7878 PutStats(stats);
7880 // use effective entries for weighted histograms: (sum_w) ^2 / sum_w2
7881 if (fSumw2.fN > 0 && fTsumw > 0 && stats[1] > 0 ) fEntries = stats[0]*stats[0]/ stats[1];
7882}
7883
7884////////////////////////////////////////////////////////////////////////////////
7885/// Return the sum of weights excluding under/overflows.
7886
7888{
7889 if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
7890
7891 Int_t bin,binx,biny,binz;
7892 Double_t sum =0;
7893 for(binz=1; binz<=fZaxis.GetNbins(); binz++) {
7894 for(biny=1; biny<=fYaxis.GetNbins(); biny++) {
7895 for(binx=1; binx<=fXaxis.GetNbins(); binx++) {
7896 bin = GetBin(binx,biny,binz);
7897 sum += RetrieveBinContent(bin);
7898 }
7899 }
7900 }
7901 return sum;
7902}
7903
7904////////////////////////////////////////////////////////////////////////////////
7905///Return integral of bin contents. Only bins in the bins range are considered.
7906///
7907/// By default the integral is computed as the sum of bin contents in the range.
7908/// if option "width" is specified, the integral is the sum of
7909/// the bin contents multiplied by the bin width in x.
7910
7912{
7914}
7915
7916////////////////////////////////////////////////////////////////////////////////
7917/// Return integral of bin contents in range [binx1,binx2].
7918///
7919/// By default the integral is computed as the sum of bin contents in the range.
7920/// if option "width" is specified, the integral is the sum of
7921/// the bin contents multiplied by the bin width in x.
7922
7923Double_t TH1::Integral(Int_t binx1, Int_t binx2, Option_t *option) const
7924{
7925 double err = 0;
7926 return DoIntegral(binx1,binx2,0,-1,0,-1,err,option);
7927}
7928
7929////////////////////////////////////////////////////////////////////////////////
7930/// Return integral of bin contents in range [binx1,binx2] and its error.
7931///
7932/// By default the integral is computed as the sum of bin contents in the range.
7933/// if option "width" is specified, the integral is the sum of
7934/// the bin contents multiplied by the bin width in x.
7935/// the error is computed using error propagation from the bin errors assuming that
7936/// all the bins are uncorrelated
7937
7938Double_t TH1::IntegralAndError(Int_t binx1, Int_t binx2, Double_t & error, Option_t *option) const
7939{
7940 return DoIntegral(binx1,binx2,0,-1,0,-1,error,option,kTRUE);
7941}
7942
7943////////////////////////////////////////////////////////////////////////////////
7944/// Internal function compute integral and optionally the error between the limits
7945/// specified by the bin number values working for all histograms (1D, 2D and 3D)
7946
7947Double_t TH1::DoIntegral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Int_t binz1, Int_t binz2, Double_t & error ,
7948 Option_t *option, Bool_t doError) const
7949{
7950 if (fBuffer) ((TH1*)this)->BufferEmpty();
7951
7952 Int_t nx = GetNbinsX() + 2;
7953 if (binx1 < 0) binx1 = 0;
7954 if (binx2 >= nx || binx2 < binx1) binx2 = nx - 1;
7955
7956 if (GetDimension() > 1) {
7957 Int_t ny = GetNbinsY() + 2;
7958 if (biny1 < 0) biny1 = 0;
7959 if (biny2 >= ny || biny2 < biny1) biny2 = ny - 1;
7960 } else {
7961 biny1 = 0; biny2 = 0;
7962 }
7963
7964 if (GetDimension() > 2) {
7965 Int_t nz = GetNbinsZ() + 2;
7966 if (binz1 < 0) binz1 = 0;
7967 if (binz2 >= nz || binz2 < binz1) binz2 = nz - 1;
7968 } else {
7969 binz1 = 0; binz2 = 0;
7970 }
7971
7972 // - Loop on bins in specified range
7973 TString opt = option;
7974 opt.ToLower();
7976 if (opt.Contains("width")) width = kTRUE;
7977
7978
7979 Double_t dx = 1., dy = .1, dz =.1;
7980 Double_t integral = 0;
7981 Double_t igerr2 = 0;
7982 for (Int_t binx = binx1; binx <= binx2; ++binx) {
7983 if (width) dx = fXaxis.GetBinWidth(binx);
7984 for (Int_t biny = biny1; biny <= biny2; ++biny) {
7985 if (width) dy = fYaxis.GetBinWidth(biny);
7986 for (Int_t binz = binz1; binz <= binz2; ++binz) {
7987 Int_t bin = GetBin(binx, biny, binz);
7988 Double_t dv = 0.0;
7989 if (width) {
7990 dz = fZaxis.GetBinWidth(binz);
7991 dv = dx * dy * dz;
7992 integral += RetrieveBinContent(bin) * dv;
7993 } else {
7994 integral += RetrieveBinContent(bin);
7995 }
7996 if (doError) {
7997 if (width) igerr2 += GetBinErrorSqUnchecked(bin) * dv * dv;
7998 else igerr2 += GetBinErrorSqUnchecked(bin);
7999 }
8000 }
8001 }
8002 }
8003
8004 if (doError) error = TMath::Sqrt(igerr2);
8005 return integral;
8006}
8007
8008////////////////////////////////////////////////////////////////////////////////
8009/// Statistical test of compatibility in shape between
8010/// this histogram and h2, using the Anderson-Darling 2 sample test.
8011///
8012/// The AD 2 sample test formula are derived from the paper
8013/// F.W Scholz, M.A. Stephens "k-Sample Anderson-Darling Test".
8014///
8015/// The test is implemented in root in the ROOT::Math::GoFTest class
8016/// It is the same formula ( (6) in the paper), and also shown in
8017/// [this preprint](http://arxiv.org/pdf/0804.0380v1.pdf)
8018///
8019/// Binned data are considered as un-binned data
8020/// with identical observation happening in the bin center.
8021///
8022/// \param[in] h2 Pointer to 1D histogram
8023/// \param[in] option is a character string to specify options
8024/// - "D" Put out a line of "Debug" printout
8025/// - "T" Return the normalized A-D test statistic
8026///
8027/// - Note1: Underflow and overflow are not considered in the test
8028/// - Note2: The test works only for un-weighted histogram (i.e. representing counts)
8029/// - Note3: The histograms are not required to have the same X axis
8030/// - Note4: The test works only for 1-dimensional histograms
8031
8033{
8034 Double_t advalue = 0;
8035 Double_t pvalue = AndersonDarlingTest(h2, advalue);
8036
8037 TString opt = option;
8038 opt.ToUpper();
8039 if (opt.Contains("D") ) {
8040 printf(" AndersonDarlingTest Prob = %g, AD TestStatistic = %g\n",pvalue,advalue);
8041 }
8042 if (opt.Contains("T") ) return advalue;
8043
8044 return pvalue;
8045}
8046
8047////////////////////////////////////////////////////////////////////////////////
8048/// Same function as above but returning also the test statistic value
8049
8050Double_t TH1::AndersonDarlingTest(const TH1 *h2, Double_t & advalue) const
8051{
8052 if (GetDimension() != 1 || h2->GetDimension() != 1) {
8053 Error("AndersonDarlingTest","Histograms must be 1-D");
8054 return -1;
8055 }
8056
8057 // empty the buffer. Probably we could add as an unbinned test
8058 if (fBuffer) ((TH1*)this)->BufferEmpty();
8059
8060 // use the BinData class
8061 ROOT::Fit::BinData data1;
8062 ROOT::Fit::BinData data2;
8063
8064 ROOT::Fit::FillData(data1, this, nullptr);
8065 ROOT::Fit::FillData(data2, h2, nullptr);
8066
8067 double pvalue;
8068 ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2, pvalue,advalue);
8069
8070 return pvalue;
8071}
8072
8073////////////////////////////////////////////////////////////////////////////////
8074/// Statistical test of compatibility in shape between
8075/// this histogram and h2, using Kolmogorov test.
8076/// Note that the KolmogorovTest (KS) test should in theory be used only for unbinned data
8077/// and not for binned data as in the case of the histogram (see NOTE 3 below).
8078/// So, before using this method blindly, read the NOTE 3.
8079///
8080/// Default: Ignore under- and overflow bins in comparison
8081///
8082/// \param[in] h2 histogram
8083/// \param[in] option is a character string to specify options
8084/// - "U" include Underflows in test (also for 2-dim)
8085/// - "O" include Overflows (also valid for 2-dim)
8086/// - "N" include comparison of normalizations
8087/// - "D" Put out a line of "Debug" printout
8088/// - "M" Return the Maximum Kolmogorov distance instead of prob
8089/// - "X" Run the pseudo experiments post-processor with the following procedure:
8090/// make pseudoexperiments based on random values from the parent distribution,
8091/// compare the KS distance of the pseudoexperiment to the parent
8092/// distribution, and count all the KS values above the value
8093/// obtained from the original data to Monte Carlo distribution.
8094/// The number of pseudo-experiments nEXPT is by default 1000, and
8095/// it can be changed by specifying the option as "X=number",
8096/// for example "X=10000" for 10000 toys.
8097/// The function returns the probability.
8098/// (thanks to Ben Kilminster to submit this procedure). Note that
8099/// this option "X" is much slower.
8100///
8101/// The returned function value is the probability of test
8102/// (much less than one means NOT compatible)
8103///
8104/// Code adapted by Rene Brun from original HBOOK routine HDIFF
8105///
8106/// NOTE1
8107/// A good description of the Kolmogorov test can be seen at:
8108/// http://www.itl.nist.gov/div898/handbook/eda/section3/eda35g.htm
8109///
8110/// NOTE2
8111/// see also alternative function TH1::Chi2Test
8112/// The Kolmogorov test is assumed to give better results than Chi2Test
8113/// in case of histograms with low statistics.
8114///
8115/// NOTE3 (Jan Conrad, Fred James)
8116/// "The returned value PROB is calculated such that it will be
8117/// uniformly distributed between zero and one for compatible histograms,
8118/// provided the data are not binned (or the number of bins is very large
8119/// compared with the number of events). Users who have access to unbinned
8120/// data and wish exact confidence levels should therefore not put their data
8121/// into histograms, but should call directly TMath::KolmogorovTest. On
8122/// the other hand, since TH1 is a convenient way of collecting data and
8123/// saving space, this function has been provided. However, the values of
8124/// PROB for binned data will be shifted slightly higher than expected,
8125/// depending on the effects of the binning. For example, when comparing two
8126/// uniform distributions of 500 events in 100 bins, the values of PROB,
8127/// instead of being exactly uniformly distributed between zero and one, have
8128/// a mean value of about 0.56. We can apply a useful
8129/// rule: As long as the bin width is small compared with any significant
8130/// physical effect (for example the experimental resolution) then the binning
8131/// cannot have an important effect. Therefore, we believe that for all
8132/// practical purposes, the probability value PROB is calculated correctly
8133/// provided the user is aware that:
8134///
8135/// 1. The value of PROB should not be expected to have exactly the correct
8136/// distribution for binned data.
8137/// 2. The user is responsible for seeing to it that the bin widths are
8138/// small compared with any physical phenomena of interest.
8139/// 3. The effect of binning (if any) is always to make the value of PROB
8140/// slightly too big. That is, setting an acceptance criterion of (PROB>0.05
8141/// will assure that at most 5% of truly compatible histograms are rejected,
8142/// and usually somewhat less."
8143///
8144/// Note also that for GoF test of unbinned data ROOT provides also the class
8145/// ROOT::Math::GoFTest. The class has also method for doing one sample tests
8146/// (i.e. comparing the data with a given distribution).
8147
8149{
8150 TString opt = option;
8151 opt.ToUpper();
8152
8153 Double_t prob = 0;
8154 TH1 *h1 = (TH1*)this;
8155 if (h2 == nullptr) return 0;
8156 const TAxis *axis1 = h1->GetXaxis();
8157 const TAxis *axis2 = h2->GetXaxis();
8158 Int_t ncx1 = axis1->GetNbins();
8159 Int_t ncx2 = axis2->GetNbins();
8160
8161 // Check consistency of dimensions
8162 if (h1->GetDimension() != 1 || h2->GetDimension() != 1) {
8163 Error("KolmogorovTest","Histograms must be 1-D\n");
8164 return 0;
8165 }
8166
8167 // Check consistency in number of channels
8168 if (ncx1 != ncx2) {
8169 Error("KolmogorovTest","Histograms have different number of bins, %d and %d\n",ncx1,ncx2);
8170 return 0;
8171 }
8172
8173 // empty the buffer. Probably we could add as an unbinned test
8174 if (fBuffer) ((TH1*)this)->BufferEmpty();
8175
8176 // Check consistency in bin edges
8177 for(Int_t i = 1; i <= axis1->GetNbins() + 1; ++i) {
8178 if(!TMath::AreEqualRel(axis1->GetBinLowEdge(i), axis2->GetBinLowEdge(i), 1.E-15)) {
8179 Error("KolmogorovTest","Histograms are not consistent: they have different bin edges");
8180 return 0;
8181 }
8182 }
8183
8184 Bool_t afunc1 = kFALSE;
8185 Bool_t afunc2 = kFALSE;
8186 Double_t sum1 = 0, sum2 = 0;
8187 Double_t ew1, ew2, w1 = 0, w2 = 0;
8188 Int_t bin;
8189 Int_t ifirst = 1;
8190 Int_t ilast = ncx1;
8191 // integral of all bins (use underflow/overflow if option)
8192 if (opt.Contains("U")) ifirst = 0;
8193 if (opt.Contains("O")) ilast = ncx1 +1;
8194 for (bin = ifirst; bin <= ilast; bin++) {
8195 sum1 += h1->RetrieveBinContent(bin);
8196 sum2 += h2->RetrieveBinContent(bin);
8197 ew1 = h1->GetBinError(bin);
8198 ew2 = h2->GetBinError(bin);
8199 w1 += ew1*ew1;
8200 w2 += ew2*ew2;
8201 }
8202 if (sum1 == 0) {
8203 Error("KolmogorovTest","Histogram1 %s integral is zero\n",h1->GetName());
8204 return 0;
8205 }
8206 if (sum2 == 0) {
8207 Error("KolmogorovTest","Histogram2 %s integral is zero\n",h2->GetName());
8208 return 0;
8209 }
8210
8211 // calculate the effective entries.
8212 // the case when errors are zero (w1 == 0 or w2 ==0) are equivalent to
8213 // compare to a function. In that case the rescaling is done only on sqrt(esum2) or sqrt(esum1)
8214 Double_t esum1 = 0, esum2 = 0;
8215 if (w1 > 0)
8216 esum1 = sum1 * sum1 / w1;
8217 else
8218 afunc1 = kTRUE; // use later for calculating z
8219
8220 if (w2 > 0)
8221 esum2 = sum2 * sum2 / w2;
8222 else
8223 afunc2 = kTRUE; // use later for calculating z
8224
8225 if (afunc2 && afunc1) {
8226 Error("KolmogorovTest","Errors are zero for both histograms\n");
8227 return 0;
8228 }
8229
8230
8231 Double_t s1 = 1/sum1;
8232 Double_t s2 = 1/sum2;
8233
8234 // Find largest difference for Kolmogorov Test
8235 Double_t dfmax =0, rsum1 = 0, rsum2 = 0;
8236
8237 for (bin=ifirst;bin<=ilast;bin++) {
8238 rsum1 += s1*h1->RetrieveBinContent(bin);
8239 rsum2 += s2*h2->RetrieveBinContent(bin);
8240 dfmax = TMath::Max(dfmax,TMath::Abs(rsum1-rsum2));
8241 }
8242
8243 // Get Kolmogorov probability
8244 Double_t z, prb1=0, prb2=0, prb3=0;
8245
8246 // case h1 is exact (has zero errors)
8247 if (afunc1)
8248 z = dfmax*TMath::Sqrt(esum2);
8249 // case h2 has zero errors
8250 else if (afunc2)
8251 z = dfmax*TMath::Sqrt(esum1);
8252 else
8253 // for comparison between two data sets
8254 z = dfmax*TMath::Sqrt(esum1*esum2/(esum1+esum2));
8255
8256 prob = TMath::KolmogorovProb(z);
8257
8258 // option N to combine normalization makes sense if both afunc1 and afunc2 are false
8259 if (opt.Contains("N") && !(afunc1 || afunc2 ) ) {
8260 // Combine probabilities for shape and normalization,
8261 prb1 = prob;
8262 Double_t d12 = esum1-esum2;
8263 Double_t chi2 = d12*d12/(esum1+esum2);
8264 prb2 = TMath::Prob(chi2,1);
8265 // see Eadie et al., section 11.6.2
8266 if (prob > 0 && prb2 > 0) prob *= prb2*(1-TMath::Log(prob*prb2));
8267 else prob = 0;
8268 }
8269 // X option. Run Pseudo-experiments to determine NULL distribution of the
8270 // KS distance. We can find the probability from the number of pseudo-experiment that have a
8271 // KS distance larger than the one opbserved in the data.
8272 // We use the histogram with the largest statistics as a parent distribution for the NULL.
8273 // Note if one histogram has zero errors is considered as a function. In that case we use it
8274 // as parent distribution for the toys.
8275 //
8276 Int_t nEXPT = 1000;
8277 if (opt.Contains("X")) {
8278 // get number of pseudo-experiment of specified
8279 if (opt.Contains("X=")) {
8280 int numpos = opt.Index("X=") + 2; // 2 is length of X=
8281 int numlen = 0;
8282 int len = opt.Length();
8283 while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) )
8284 numlen++;
8285 TString snum = opt(numpos,numlen);
8286 int num = atoi(snum.Data());
8287 if (num <= 0)
8288 Warning("KolmogorovTest","invalid number of toys given: %d - use 1000",num);
8289 else
8290 nEXPT = num;
8291 }
8292
8293 Double_t dSEXPT;
8294 TH1D hparent;
8295 // we cannot have afunc1 and func2 both True
8296 if (afunc1 || esum1 > esum2 ) h1->Copy(hparent);
8297 else h2->Copy(hparent);
8298
8299 // copy h1Expt from h1 and h2. It is just needed to get the correct binning
8300
8301
8302 if (hparent.GetMinimum() < 0.0) {
8303 // we need to create a new histogram
8304 // With negative bins we can't draw random samples in a meaningful way.
8305 Warning("KolmogorovTest", "Detected bins with negative weights, these have been ignored and output might be "
8306 "skewed. Reduce number of bins for histogram?");
8307 while (hparent.GetMinimum() < 0.0) {
8308 Int_t idx = hparent.GetMinimumBin();
8309 hparent.SetBinContent(idx, 0.0);
8310 }
8311 }
8312
8313 // make nEXPT experiments (this should be a parameter)
8314 prb3 = 0;
8315 TH1D h1Expt;
8316 h1->Copy(h1Expt);
8317 TH1D h2Expt;
8318 h1->Copy(h2Expt);
8319 // loop on pseudoexperients and generate the two histograms h1Expt and h2Expt according to the
8320 // parent distribution. In case the parent distribution is not an histogram but a function randomize only one
8321 // histogram
8322 for (Int_t i=0; i < nEXPT; i++) {
8323 if (!afunc1) {
8324 h1Expt.Reset();
8325 h1Expt.FillRandom(&hparent, (Int_t)esum1);
8326 }
8327 if (!afunc2) {
8328 h2Expt.Reset();
8329 h2Expt.FillRandom(&hparent, (Int_t)esum2);
8330 }
8331 // note we cannot have both afunc1 and afunc2 to be true
8332 if (afunc1)
8333 dSEXPT = hparent.KolmogorovTest(&h2Expt,"M");
8334 else if (afunc2)
8335 dSEXPT = hparent.KolmogorovTest(&h1Expt,"M");
8336 else
8337 dSEXPT = h1Expt.KolmogorovTest(&h2Expt,"M");
8338 // count number of cases toy KS distance (TS) is larger than oberved one
8339 if (dSEXPT>dfmax) prb3 += 1.0;
8340 }
8341 // compute p-value
8342 prb3 /= (Double_t)nEXPT;
8343 }
8344
8345
8346 // debug printout
8347 if (opt.Contains("D")) {
8348 printf(" Kolmo Prob h1 = %s, sum bin content =%g effective entries =%g\n",h1->GetName(),sum1,esum1);
8349 printf(" Kolmo Prob h2 = %s, sum bin content =%g effective entries =%g\n",h2->GetName(),sum2,esum2);
8350 printf(" Kolmo Prob = %g, Max Dist = %g\n",prob,dfmax);
8351 if (opt.Contains("N"))
8352 printf(" Kolmo Prob = %f for shape alone, =%f for normalisation alone\n",prb1,prb2);
8353 if (opt.Contains("X"))
8354 printf(" Kolmo Prob = %f with %d pseudo-experiments\n",prb3,nEXPT);
8355 }
8356 // This numerical error condition should never occur:
8357 if (TMath::Abs(rsum1-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h1=%s\n",h1->GetName());
8358 if (TMath::Abs(rsum2-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h2=%s\n",h2->GetName());
8359
8360 if(opt.Contains("M")) return dfmax;
8361 else if(opt.Contains("X")) return prb3;
8362 else return prob;
8363}
8364
8365////////////////////////////////////////////////////////////////////////////////
8366/// Replace bin contents by the contents of array content
8367
8368void TH1::SetContent(const Double_t *content)
8369{
8370 fEntries = fNcells;
8371 fTsumw = 0;
8372 for (Int_t i = 0; i < fNcells; ++i) UpdateBinContent(i, content[i]);
8373}
8374
8375////////////////////////////////////////////////////////////////////////////////
8376/// Return contour values into array levels if pointer levels is non zero.
8377///
8378/// The function returns the number of contour levels.
8379/// see GetContourLevel to return one contour only
8380
8382{
8383 Int_t nlevels = fContour.fN;
8384 if (levels) {
8385 if (nlevels == 0) {
8386 nlevels = 20;
8387 SetContour(nlevels);
8388 } else {
8389 if (TestBit(kUserContour) == 0) SetContour(nlevels);
8390 }
8391 for (Int_t level=0; level<nlevels; level++) levels[level] = fContour.fArray[level];
8392 }
8393 return nlevels;
8394}
8395
8396////////////////////////////////////////////////////////////////////////////////
8397/// Return value of contour number level.
8398/// Use GetContour to return the array of all contour levels
8399
8401{
8402 return (level >= 0 && level < fContour.fN) ? fContour.fArray[level] : 0.0;
8403}
8404
8405////////////////////////////////////////////////////////////////////////////////
8406/// Return the value of contour number "level" in Pad coordinates.
8407/// ie: if the Pad is in log scale along Z it returns le log of the contour level
8408/// value. See GetContour to return the array of all contour levels
8409
8411{
8412 if (level <0 || level >= fContour.fN) return 0;
8413 Double_t zlevel = fContour.fArray[level];
8414
8415 // In case of user defined contours and Pad in log scale along Z,
8416 // fContour.fArray doesn't contain the log of the contour whereas it does
8417 // in case of equidistant contours.
8418 if (gPad && gPad->GetLogz() && TestBit(kUserContour)) {
8419 if (zlevel <= 0) return 0;
8420 zlevel = TMath::Log10(zlevel);
8421 }
8422 return zlevel;
8423}
8424
8425////////////////////////////////////////////////////////////////////////////////
8426/// Set the maximum number of entries to be kept in the buffer.
8427
8428void TH1::SetBuffer(Int_t buffersize, Option_t * /*option*/)
8429{
8430 if (fBuffer) {
8431 BufferEmpty();
8432 delete [] fBuffer;
8433 fBuffer = nullptr;
8434 }
8435 if (buffersize <= 0) {
8436 fBufferSize = 0;
8437 return;
8438 }
8439 if (buffersize < 100) buffersize = 100;
8440 fBufferSize = 1 + buffersize*(fDimension+1);
8442 memset(fBuffer, 0, sizeof(Double_t)*fBufferSize);
8443}
8444
8445////////////////////////////////////////////////////////////////////////////////
8446/// Set the number and values of contour levels.
8447///
8448/// By default the number of contour levels is set to 20. The contours values
8449/// in the array "levels" should be specified in increasing order.
8450///
8451/// if argument levels = 0 or missing, equidistant contours are computed
8452
8453void TH1::SetContour(Int_t nlevels, const Double_t *levels)
8454{
8455 Int_t level;
8457 if (nlevels <=0 ) {
8458 fContour.Set(0);
8459 return;
8460 }
8461 fContour.Set(nlevels);
8462
8463 // - Contour levels are specified
8464 if (levels) {
8466 for (level=0; level<nlevels; level++) fContour.fArray[level] = levels[level];
8467 } else {
8468 // - contour levels are computed automatically as equidistant contours
8469 Double_t zmin = GetMinimum();
8470 Double_t zmax = GetMaximum();
8471 if ((zmin == zmax) && (zmin != 0)) {
8472 zmax += 0.01*TMath::Abs(zmax);
8473 zmin -= 0.01*TMath::Abs(zmin);
8474 }
8475 Double_t dz = (zmax-zmin)/Double_t(nlevels);
8476 if (gPad && gPad->GetLogz()) {
8477 if (zmax <= 0) return;
8478 if (zmin <= 0) zmin = 0.001*zmax;
8479 zmin = TMath::Log10(zmin);
8480 zmax = TMath::Log10(zmax);
8481 dz = (zmax-zmin)/Double_t(nlevels);
8482 }
8483 for (level=0; level<nlevels; level++) {
8484 fContour.fArray[level] = zmin + dz*Double_t(level);
8485 }
8486 }
8487}
8488
8489////////////////////////////////////////////////////////////////////////////////
8490/// Set value for one contour level.
8491
8493{
8494 if (level < 0 || level >= fContour.fN) return;
8496 fContour.fArray[level] = value;
8497}
8498
8499////////////////////////////////////////////////////////////////////////////////
8500/// Return maximum value smaller than maxval of bins in the range,
8501/// unless the value has been overridden by TH1::SetMaximum,
8502/// in which case it returns that value. This happens, for example,
8503/// when the histogram is drawn and the y or z axis limits are changed
8504///
8505/// To get the maximum value of bins in the histogram regardless of
8506/// whether the value has been overridden (using TH1::SetMaximum), use
8507///
8508/// ~~~ {.cpp}
8509/// h->GetBinContent(h->GetMaximumBin())
8510/// ~~~
8511///
8512/// TH1::GetMaximumBin can be used to get the location of the maximum
8513/// value.
8514
8515Double_t TH1::GetMaximum(Double_t maxval) const
8516{
8517 if (fMaximum != -1111) return fMaximum;
8518
8519 // empty the buffer
8520 if (fBuffer) ((TH1*)this)->BufferEmpty();
8521
8522 Int_t bin, binx, biny, binz;
8523 Int_t xfirst = fXaxis.GetFirst();
8524 Int_t xlast = fXaxis.GetLast();
8525 Int_t yfirst = fYaxis.GetFirst();
8526 Int_t ylast = fYaxis.GetLast();
8527 Int_t zfirst = fZaxis.GetFirst();
8528 Int_t zlast = fZaxis.GetLast();
8529 Double_t maximum = -FLT_MAX, value;
8530 for (binz=zfirst;binz<=zlast;binz++) {
8531 for (biny=yfirst;biny<=ylast;biny++) {
8532 for (binx=xfirst;binx<=xlast;binx++) {
8533 bin = GetBin(binx,biny,binz);
8535 if (value > maximum && value < maxval) maximum = value;
8536 }
8537 }
8538 }
8539 return maximum;
8540}
8541
8542////////////////////////////////////////////////////////////////////////////////
8543/// Return location of bin with maximum value in the range.
8544///
8545/// TH1::GetMaximum can be used to get the maximum value.
8546
8548{
8549 Int_t locmax, locmay, locmaz;
8550 return GetMaximumBin(locmax, locmay, locmaz);
8551}
8552
8553////////////////////////////////////////////////////////////////////////////////
8554/// Return location of bin with maximum value in the range.
8555
8556Int_t TH1::GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locmaz) const
8557{
8558 // empty the buffer
8559 if (fBuffer) ((TH1*)this)->BufferEmpty();
8560
8561 Int_t bin, binx, biny, binz;
8562 Int_t locm;
8563 Int_t xfirst = fXaxis.GetFirst();
8564 Int_t xlast = fXaxis.GetLast();
8565 Int_t yfirst = fYaxis.GetFirst();
8566 Int_t ylast = fYaxis.GetLast();
8567 Int_t zfirst = fZaxis.GetFirst();
8568 Int_t zlast = fZaxis.GetLast();
8569 Double_t maximum = -FLT_MAX, value;
8570 locm = locmax = locmay = locmaz = 0;
8571 for (binz=zfirst;binz<=zlast;binz++) {
8572 for (biny=yfirst;biny<=ylast;biny++) {
8573 for (binx=xfirst;binx<=xlast;binx++) {
8574 bin = GetBin(binx,biny,binz);
8576 if (value > maximum) {
8577 maximum = value;
8578 locm = bin;
8579 locmax = binx;
8580 locmay = biny;
8581 locmaz = binz;
8582 }
8583 }
8584 }
8585 }
8586 return locm;
8587}
8588
8589////////////////////////////////////////////////////////////////////////////////
8590/// Return minimum value larger than minval of bins in the range,
8591/// unless the value has been overridden by TH1::SetMinimum,
8592/// in which case it returns that value. This happens, for example,
8593/// when the histogram is drawn and the y or z axis limits are changed
8594///
8595/// To get the minimum value of bins in the histogram regardless of
8596/// whether the value has been overridden (using TH1::SetMinimum), use
8597///
8598/// ~~~ {.cpp}
8599/// h->GetBinContent(h->GetMinimumBin())
8600/// ~~~
8601///
8602/// TH1::GetMinimumBin can be used to get the location of the
8603/// minimum value.
8604
8605Double_t TH1::GetMinimum(Double_t minval) const
8606{
8607 if (fMinimum != -1111) return fMinimum;
8608
8609 // empty the buffer
8610 if (fBuffer) ((TH1*)this)->BufferEmpty();
8611
8612 Int_t bin, binx, biny, binz;
8613 Int_t xfirst = fXaxis.GetFirst();
8614 Int_t xlast = fXaxis.GetLast();
8615 Int_t yfirst = fYaxis.GetFirst();
8616 Int_t ylast = fYaxis.GetLast();
8617 Int_t zfirst = fZaxis.GetFirst();
8618 Int_t zlast = fZaxis.GetLast();
8619 Double_t minimum=FLT_MAX, value;
8620 for (binz=zfirst;binz<=zlast;binz++) {
8621 for (biny=yfirst;biny<=ylast;biny++) {
8622 for (binx=xfirst;binx<=xlast;binx++) {
8623 bin = GetBin(binx,biny,binz);
8625 if (value < minimum && value > minval) minimum = value;
8626 }
8627 }
8628 }
8629 return minimum;
8630}
8631
8632////////////////////////////////////////////////////////////////////////////////
8633/// Return location of bin with minimum value in the range.
8634
8636{
8637 Int_t locmix, locmiy, locmiz;
8638 return GetMinimumBin(locmix, locmiy, locmiz);
8639}
8640
8641////////////////////////////////////////////////////////////////////////////////
8642/// Return location of bin with minimum value in the range.
8643
8644Int_t TH1::GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locmiz) const
8645{
8646 // empty the buffer
8647 if (fBuffer) ((TH1*)this)->BufferEmpty();
8648
8649 Int_t bin, binx, biny, binz;
8650 Int_t locm;
8651 Int_t xfirst = fXaxis.GetFirst();
8652 Int_t xlast = fXaxis.GetLast();
8653 Int_t yfirst = fYaxis.GetFirst();
8654 Int_t ylast = fYaxis.GetLast();
8655 Int_t zfirst = fZaxis.GetFirst();
8656 Int_t zlast = fZaxis.GetLast();
8657 Double_t minimum = FLT_MAX, value;
8658 locm = locmix = locmiy = locmiz = 0;
8659 for (binz=zfirst;binz<=zlast;binz++) {
8660 for (biny=yfirst;biny<=ylast;biny++) {
8661 for (binx=xfirst;binx<=xlast;binx++) {
8662 bin = GetBin(binx,biny,binz);
8664 if (value < minimum) {
8665 minimum = value;
8666 locm = bin;
8667 locmix = binx;
8668 locmiy = biny;
8669 locmiz = binz;
8670 }
8671 }
8672 }
8673 }
8674 return locm;
8675}
8676
8677///////////////////////////////////////////////////////////////////////////////
8678/// Retrieve the minimum and maximum values in the histogram
8679///
8680/// This will not return a cached value and will always search the
8681/// histogram for the min and max values. The user can condition whether
8682/// or not to call this with the GetMinimumStored() and GetMaximumStored()
8683/// methods. If the cache is empty, then the value will be -1111. Users
8684/// can then use the SetMinimum() or SetMaximum() methods to cache the results.
8685/// For example, the following recipe will make efficient use of this method
8686/// and the cached minimum and maximum values.
8687//
8688/// \code{.cpp}
8689/// Double_t currentMin = pHist->GetMinimumStored();
8690/// Double_t currentMax = pHist->GetMaximumStored();
8691/// if ((currentMin == -1111) || (currentMax == -1111)) {
8692/// pHist->GetMinimumAndMaximum(currentMin, currentMax);
8693/// pHist->SetMinimum(currentMin);
8694/// pHist->SetMaximum(currentMax);
8695/// }
8696/// \endcode
8697///
8698/// \param min reference to variable that will hold found minimum value
8699/// \param max reference to variable that will hold found maximum value
8700
8701void TH1::GetMinimumAndMaximum(Double_t& min, Double_t& max) const
8702{
8703 // empty the buffer
8704 if (fBuffer) ((TH1*)this)->BufferEmpty();
8705
8706 Int_t bin, binx, biny, binz;
8707 Int_t xfirst = fXaxis.GetFirst();
8708 Int_t xlast = fXaxis.GetLast();
8709 Int_t yfirst = fYaxis.GetFirst();
8710 Int_t ylast = fYaxis.GetLast();
8711 Int_t zfirst = fZaxis.GetFirst();
8712 Int_t zlast = fZaxis.GetLast();
8713 min=TMath::Infinity();
8714 max=-TMath::Infinity();
8716 for (binz=zfirst;binz<=zlast;binz++) {
8717 for (biny=yfirst;biny<=ylast;biny++) {
8718 for (binx=xfirst;binx<=xlast;binx++) {
8719 bin = GetBin(binx,biny,binz);
8721 if (value < min) min = value;
8722 if (value > max) max = value;
8723 }
8724 }
8725 }
8726}
8727
8728////////////////////////////////////////////////////////////////////////////////
8729/// Redefine x axis parameters.
8730///
8731/// The X axis parameters are modified.
8732/// The bins content array is resized
8733/// if errors (Sumw2) the errors array is resized
8734/// The previous bin contents are lost
8735/// To change only the axis limits, see TAxis::SetRange
8736
8738{
8739 if (GetDimension() != 1) {
8740 Error("SetBins","Operation only valid for 1-d histograms");
8741 return;
8742 }
8743 fXaxis.SetRange(0,0);
8744 fXaxis.Set(nx,xmin,xmax);
8745 fYaxis.Set(1,0,1);
8746 fZaxis.Set(1,0,1);
8747 fNcells = nx+2;
8749 if (fSumw2.fN) {
8751 }
8752}
8753
8754////////////////////////////////////////////////////////////////////////////////
8755/// Redefine x axis parameters with variable bin sizes.
8756///
8757/// The X axis parameters are modified.
8758/// The bins content array is resized
8759/// if errors (Sumw2) the errors array is resized
8760/// The previous bin contents are lost
8761/// To change only the axis limits, see TAxis::SetRange
8762/// xBins is supposed to be of length nx+1
8763
8764void TH1::SetBins(Int_t nx, const Double_t *xBins)
8765{
8766 if (GetDimension() != 1) {
8767 Error("SetBins","Operation only valid for 1-d histograms");
8768 return;
8769 }
8770 fXaxis.SetRange(0,0);
8771 fXaxis.Set(nx,xBins);
8772 fYaxis.Set(1,0,1);
8773 fZaxis.Set(1,0,1);
8774 fNcells = nx+2;
8776 if (fSumw2.fN) {
8778 }
8779}
8780
8781////////////////////////////////////////////////////////////////////////////////
8782/// Redefine x and y axis parameters.
8783///
8784/// The X and Y axis parameters are modified.
8785/// The bins content array is resized
8786/// if errors (Sumw2) the errors array is resized
8787/// The previous bin contents are lost
8788/// To change only the axis limits, see TAxis::SetRange
8789
8791{
8792 if (GetDimension() != 2) {
8793 Error("SetBins","Operation only valid for 2-D histograms");
8794 return;
8795 }
8796 fXaxis.SetRange(0,0);
8797 fYaxis.SetRange(0,0);
8798 fXaxis.Set(nx,xmin,xmax);
8799 fYaxis.Set(ny,ymin,ymax);
8800 fZaxis.Set(1,0,1);
8801 fNcells = (nx+2)*(ny+2);
8803 if (fSumw2.fN) {
8805 }
8806}
8807
8808////////////////////////////////////////////////////////////////////////////////
8809/// Redefine x and y axis parameters with variable bin sizes.
8810///
8811/// The X and Y axis parameters are modified.
8812/// The bins content array is resized
8813/// if errors (Sumw2) the errors array is resized
8814/// The previous bin contents are lost
8815/// To change only the axis limits, see TAxis::SetRange
8816/// xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1
8817
8818void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins)
8819{
8820 if (GetDimension() != 2) {
8821 Error("SetBins","Operation only valid for 2-D histograms");
8822 return;
8823 }
8824 fXaxis.SetRange(0,0);
8825 fYaxis.SetRange(0,0);
8826 fXaxis.Set(nx,xBins);
8827 fYaxis.Set(ny,yBins);
8828 fZaxis.Set(1,0,1);
8829 fNcells = (nx+2)*(ny+2);
8831 if (fSumw2.fN) {
8833 }
8834}
8835
8836////////////////////////////////////////////////////////////////////////////////
8837/// Redefine x, y and z axis parameters.
8838///
8839/// The X, Y and Z axis parameters are modified.
8840/// The bins content array is resized
8841/// if errors (Sumw2) the errors array is resized
8842/// The previous bin contents are lost
8843/// To change only the axis limits, see TAxis::SetRange
8844
8846{
8847 if (GetDimension() != 3) {
8848 Error("SetBins","Operation only valid for 3-D histograms");
8849 return;
8850 }
8851 fXaxis.SetRange(0,0);
8852 fYaxis.SetRange(0,0);
8853 fZaxis.SetRange(0,0);
8854 fXaxis.Set(nx,xmin,xmax);
8855 fYaxis.Set(ny,ymin,ymax);
8856 fZaxis.Set(nz,zmin,zmax);
8857 fNcells = (nx+2)*(ny+2)*(nz+2);
8859 if (fSumw2.fN) {
8861 }
8862}
8863
8864////////////////////////////////////////////////////////////////////////////////
8865/// Redefine x, y and z axis parameters with variable bin sizes.
8866///
8867/// The X, Y and Z axis parameters are modified.
8868/// The bins content array is resized
8869/// if errors (Sumw2) the errors array is resized
8870/// The previous bin contents are lost
8871/// To change only the axis limits, see TAxis::SetRange
8872/// xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1,
8873/// zBins is supposed to be of length nz+1
8874
8875void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins, Int_t nz, const Double_t *zBins)
8876{
8877 if (GetDimension() != 3) {
8878 Error("SetBins","Operation only valid for 3-D histograms");
8879 return;
8880 }
8881 fXaxis.SetRange(0,0);
8882 fYaxis.SetRange(0,0);
8883 fZaxis.SetRange(0,0);
8884 fXaxis.Set(nx,xBins);
8885 fYaxis.Set(ny,yBins);
8886 fZaxis.Set(nz,zBins);
8887 fNcells = (nx+2)*(ny+2)*(nz+2);
8889 if (fSumw2.fN) {
8891 }
8892}
8893
8894////////////////////////////////////////////////////////////////////////////////
8895/// By default, when a histogram is created, it is added to the list
8896/// of histogram objects in the current directory in memory.
8897/// Remove reference to this histogram from current directory and add
8898/// reference to new directory dir. dir can be 0 in which case the
8899/// histogram does not belong to any directory.
8900///
8901/// Note that the directory is not a real property of the histogram and
8902/// it will not be copied when the histogram is copied or cloned.
8903/// If the user wants to have the copied (cloned) histogram in the same
8904/// directory, he needs to set again the directory using SetDirectory to the
8905/// copied histograms
8906
8908{
8909 if (fDirectory == dir) return;
8910 if (fDirectory) fDirectory->Remove(this);
8911 fDirectory = dir;
8912 if (fDirectory) {
8914 fDirectory->Append(this);
8915 }
8916}
8917
8918////////////////////////////////////////////////////////////////////////////////
8919/// Replace bin errors by values in array error.
8920
8921void TH1::SetError(const Double_t *error)
8922{
8923 for (Int_t i = 0; i < fNcells; ++i) SetBinError(i, error[i]);
8924}
8925
8926////////////////////////////////////////////////////////////////////////////////
8927/// Change the name of this histogram
8929
8930void TH1::SetName(const char *name)
8931{
8932 // Histograms are named objects in a THashList.
8933 // We must update the hashlist if we change the name
8934 // We protect this operation
8936 if (fDirectory) fDirectory->Remove(this);
8937 fName = name;
8938 if (fDirectory) fDirectory->Append(this);
8939}
8940
8941////////////////////////////////////////////////////////////////////////////////
8942/// Change the name and title of this histogram
8943
8944void TH1::SetNameTitle(const char *name, const char *title)
8945{
8946 // Histograms are named objects in a THashList.
8947 // We must update the hashlist if we change the name
8948 SetName(name);
8949 SetTitle(title);
8950}
8951
8952////////////////////////////////////////////////////////////////////////////////
8953/// Set statistics option on/off.
8954///
8955/// By default, the statistics box is drawn.
8956/// The paint options can be selected via gStyle->SetOptStat.
8957/// This function sets/resets the kNoStats bit in the histogram object.
8958/// It has priority over the Style option.
8959
8960void TH1::SetStats(Bool_t stats)
8961{
8963 if (!stats) {
8965 //remove the "stats" object from the list of functions
8966 if (fFunctions) {
8967 TObject *obj = fFunctions->FindObject("stats");
8968 if (obj) {
8969 fFunctions->Remove(obj);
8970 delete obj;
8971 }
8972 }
8973 }
8974}
8975
8976////////////////////////////////////////////////////////////////////////////////
8977/// Create structure to store sum of squares of weights.
8978///
8979/// if histogram is already filled, the sum of squares of weights
8980/// is filled with the existing bin contents
8981///
8982/// The error per bin will be computed as sqrt(sum of squares of weight)
8983/// for each bin.
8984///
8985/// This function is automatically called when the histogram is created
8986/// if the static function TH1::SetDefaultSumw2 has been called before.
8987/// If flag = false the structure containing the sum of the square of weights
8988/// is rest and it will be empty, but it is not deleted (i.e. GetSumw2()->fN = 0)
8989
8990void TH1::Sumw2(Bool_t flag)
8991{
8992 if (!flag) {
8993 // clear the array if existing - do nothing otherwise
8994 if (fSumw2.fN > 0 ) fSumw2.Set(0);
8995 return;
8996 }
8997
8998 if (fSumw2.fN == fNcells) {
8999 if (!fgDefaultSumw2 )
9000 Warning("Sumw2","Sum of squares of weights structure already created");
9001 return;
9002 }
9003
9005
9006 // empty the buffer
9007 if (fBuffer) BufferEmpty();
9008
9009 if (fEntries > 0)
9010 for (Int_t i = 0; i < fNcells; ++i)
9012}
9013
9014////////////////////////////////////////////////////////////////////////////////
9015/// Return pointer to function with name.
9016///
9017///
9018/// Functions such as TH1::Fit store the fitted function in the list of
9019/// functions of this histogram.
9020
9021TF1 *TH1::GetFunction(const char *name) const
9022{
9023 return (TF1*)fFunctions->FindObject(name);
9024}
9025
9026////////////////////////////////////////////////////////////////////////////////
9027/// Return value of error associated to bin number bin.
9028///
9029/// if the sum of squares of weights has been defined (via Sumw2),
9030/// this function returns the sqrt(sum of w2).
9031/// otherwise it returns the sqrt(contents) for this bin.
9032
9034{
9035 if (bin < 0) bin = 0;
9036 if (bin >= fNcells) bin = fNcells-1;
9037 if (fBuffer) ((TH1*)this)->BufferEmpty();
9038 if (fSumw2.fN) return TMath::Sqrt(fSumw2.fArray[bin]);
9039
9041}
9042
9043////////////////////////////////////////////////////////////////////////////////
9044/// Return lower error associated to bin number bin.
9045///
9046/// The error will depend on the statistic option used will return
9047/// the binContent - lower interval value
9048
9050{
9051 if (fBinStatErrOpt == kNormal) return GetBinError(bin);
9052 // in case of weighted histogram check if it is really weighted
9053 if (fSumw2.fN && fTsumw != fTsumw2) return GetBinError(bin);
9054
9055 if (bin < 0) bin = 0;
9056 if (bin >= fNcells) bin = fNcells-1;
9057 if (fBuffer) ((TH1*)this)->BufferEmpty();
9058
9059 Double_t alpha = 1.- 0.682689492;
9060 if (fBinStatErrOpt == kPoisson2) alpha = 0.05;
9061
9063 Int_t n = int(c);
9064 if (n < 0) {
9065 Warning("GetBinErrorLow","Histogram has negative bin content-force usage to normal errors");
9066 ((TH1*)this)->fBinStatErrOpt = kNormal;
9067 return GetBinError(bin);
9068 }
9069
9070 if (n == 0) return 0;
9071 return c - ROOT::Math::gamma_quantile( alpha/2, n, 1.);
9072}
9073
9074////////////////////////////////////////////////////////////////////////////////
9075/// Return upper error associated to bin number bin.
9076///
9077/// The error will depend on the statistic option used will return
9078/// the binContent - upper interval value
9079
9081{
9082 if (fBinStatErrOpt == kNormal) return GetBinError(bin);
9083 // in case of weighted histogram check if it is really weighted
9084 if (fSumw2.fN && fTsumw != fTsumw2) return GetBinError(bin);
9085 if (bin < 0) bin = 0;
9086 if (bin >= fNcells) bin = fNcells-1;
9087 if (fBuffer) ((TH1*)this)->BufferEmpty();
9088
9089 Double_t alpha = 1.- 0.682689492;
9090 if (fBinStatErrOpt == kPoisson2) alpha = 0.05;
9091
9093 Int_t n = int(c);
9094 if (n < 0) {
9095 Warning("GetBinErrorUp","Histogram has negative bin content-force usage to normal errors");
9096 ((TH1*)this)->fBinStatErrOpt = kNormal;
9097 return GetBinError(bin);
9098 }
9099
9100 // for N==0 return an upper limit at 0.68 or (1-alpha)/2 ?
9101 // decide to return always (1-alpha)/2 upper interval
9102 //if (n == 0) return ROOT::Math::gamma_quantile_c(alpha,n+1,1);
9103 return ROOT::Math::gamma_quantile_c( alpha/2, n+1, 1) - c;
9104}
9105
9106//L.M. These following getters are useless and should be probably deprecated
9107////////////////////////////////////////////////////////////////////////////////
9108/// Return bin center for 1D histogram.
9109/// Better to use h1.GetXaxis()->GetBinCenter(bin)
9110
9112{
9113 if (fDimension == 1) return fXaxis.GetBinCenter(bin);
9114 Error("GetBinCenter","Invalid method for a %d-d histogram - return a NaN",fDimension);
9115 return TMath::QuietNaN();
9116}
9117
9118////////////////////////////////////////////////////////////////////////////////
9119/// Return bin lower edge for 1D histogram.
9120/// Better to use h1.GetXaxis()->GetBinLowEdge(bin)
9121
9123{
9124 if (fDimension == 1) return fXaxis.GetBinLowEdge(bin);
9125 Error("GetBinLowEdge","Invalid method for a %d-d histogram - return a NaN",fDimension);
9126 return TMath::QuietNaN();
9127}
9128
9129////////////////////////////////////////////////////////////////////////////////
9130/// Return bin width for 1D histogram.
9131/// Better to use h1.GetXaxis()->GetBinWidth(bin)
9132
9134{
9135 if (fDimension == 1) return fXaxis.GetBinWidth(bin);
9136 Error("GetBinWidth","Invalid method for a %d-d histogram - return a NaN",fDimension);
9137 return TMath::QuietNaN();
9138}
9139
9140////////////////////////////////////////////////////////////////////////////////
9141/// Fill array with center of bins for 1D histogram
9142/// Better to use h1.GetXaxis()->GetCenter(center)
9143
9144void TH1::GetCenter(Double_t *center) const
9145{
9146 if (fDimension == 1) {
9147 fXaxis.GetCenter(center);
9148 return;
9149 }
9150 Error("GetCenter","Invalid method for a %d-d histogram ",fDimension);
9151}
9152
9153////////////////////////////////////////////////////////////////////////////////
9154/// Fill array with low edge of bins for 1D histogram
9155/// Better to use h1.GetXaxis()->GetLowEdge(edge)
9156
9157void TH1::GetLowEdge(Double_t *edge) const
9158{
9159 if (fDimension == 1) {
9160 fXaxis.GetLowEdge(edge);
9161 return;
9162 }
9163 Error("GetLowEdge","Invalid method for a %d-d histogram ",fDimension);
9164}
9165
9166////////////////////////////////////////////////////////////////////////////////
9167/// Set the bin Error
9168/// Note that this resets the bin eror option to be of Normal Type and for the
9169/// non-empty bin the bin error is set by default to the square root of their content.
9170/// Note that in case the user sets after calling SetBinError explicitly a new bin content (e.g. using SetBinContent)
9171/// he needs then to provide also the corresponding bin error (using SetBinError) since the bin error
9172/// will not be recalculated after setting the content and a default error = 0 will be used for those bins.
9173///
9174/// See convention for numbering bins in TH1::GetBin
9175
9176void TH1::SetBinError(Int_t bin, Double_t error)
9177{
9178 if (bin < 0 || bin>= fNcells) return;
9179 if (!fSumw2.fN) Sumw2();
9180 fSumw2.fArray[bin] = error * error;
9181 // reset the bin error option
9183}
9184
9185////////////////////////////////////////////////////////////////////////////////
9186/// Set bin content
9187/// see convention for numbering bins in TH1::GetBin
9188/// In case the bin number is greater than the number of bins and
9189/// the timedisplay option is set or CanExtendAllAxes(),
9190/// the number of bins is automatically doubled to accommodate the new bin
9191
9192void TH1::SetBinContent(Int_t bin, Double_t content)
9193{
9194 fEntries++;
9195 fTsumw = 0;
9196 if (bin < 0) return;
9197 if (bin >= fNcells-1) {
9199 while (bin >= fNcells-1) LabelsInflate();
9200 } else {
9201 if (bin == fNcells-1) UpdateBinContent(bin, content);
9202 return;
9203 }
9204 }
9205 UpdateBinContent(bin, content);
9206}
9207
9208////////////////////////////////////////////////////////////////////////////////
9209/// See convention for numbering bins in TH1::GetBin
9210
9211void TH1::SetBinError(Int_t binx, Int_t biny, Double_t error)
9212{
9213 if (binx < 0 || binx > fXaxis.GetNbins() + 1) return;
9214 if (biny < 0 || biny > fYaxis.GetNbins() + 1) return;
9215 SetBinError(GetBin(binx, biny), error);
9216}
9217
9218////////////////////////////////////////////////////////////////////////////////
9219/// See convention for numbering bins in TH1::GetBin
9220
9221void TH1::SetBinError(Int_t binx, Int_t biny, Int_t binz, Double_t error)
9222{
9223 if (binx < 0 || binx > fXaxis.GetNbins() + 1) return;
9224 if (biny < 0 || biny > fYaxis.GetNbins() + 1) return;
9225 if (binz < 0 || binz > fZaxis.GetNbins() + 1) return;
9226 SetBinError(GetBin(binx, biny, binz), error);
9227}
9228
9229////////////////////////////////////////////////////////////////////////////////
9230/// This function calculates the background spectrum in this histogram.
9231/// The background is returned as a histogram.
9232///
9233/// \param[in] niter number of iterations (default value = 2)
9234/// Increasing niter make the result smoother and lower.
9235/// \param[in] option may contain one of the following options
9236/// - to set the direction parameter
9237/// "BackDecreasingWindow". By default the direction is BackIncreasingWindow
9238/// - filterOrder-order of clipping filter (default "BackOrder2")
9239/// possible values= "BackOrder4" "BackOrder6" "BackOrder8"
9240/// - "nosmoothing" - if selected, the background is not smoothed
9241/// By default the background is smoothed.
9242/// - smoothWindow - width of smoothing window, (default is "BackSmoothing3")
9243/// possible values= "BackSmoothing5" "BackSmoothing7" "BackSmoothing9"
9244/// "BackSmoothing11" "BackSmoothing13" "BackSmoothing15"
9245/// - "nocompton" - if selected the estimation of Compton edge
9246/// will be not be included (by default the compton estimation is set)
9247/// - "same" if this option is specified, the resulting background
9248/// histogram is superimposed on the picture in the current pad.
9249/// This option is given by default.
9250///
9251/// NOTE that the background is only evaluated in the current range of this histogram.
9252/// i.e., if this has a bin range (set via h->GetXaxis()->SetRange(binmin, binmax),
9253/// the returned histogram will be created with the same number of bins
9254/// as this input histogram, but only bins from binmin to binmax will be filled
9255/// with the estimated background.
9256
9258{
9259 return (TH1*)gROOT->ProcessLineFast(TString::Format("TSpectrum::StaticBackground((TH1*)0x%zx,%d,\"%s\")",
9260 (size_t)this, niter, option).Data());
9261}
9262
9263////////////////////////////////////////////////////////////////////////////////
9264/// Interface to TSpectrum::Search.
9265/// The function finds peaks in this histogram where the width is > sigma
9266/// and the peak maximum greater than threshold*maximum bin content of this.
9267/// For more details see TSpectrum::Search.
9268/// Note the difference in the default value for option compared to TSpectrum::Search
9269/// option="" by default (instead of "goff").
9270
9272{
9273 return (Int_t)gROOT->ProcessLineFast(TString::Format("TSpectrum::StaticSearch((TH1*)0x%zx,%g,\"%s\",%g)",
9274 (size_t)this, sigma, option, threshold).Data());
9275}
9276
9277////////////////////////////////////////////////////////////////////////////////
9278/// For a given transform (first parameter), fills the histogram (second parameter)
9279/// with the transform output data, specified in the third parameter
9280/// If the 2nd parameter h_output is empty, a new histogram (TH1D or TH2D) is created
9281/// and the user is responsible for deleting it.
9282///
9283/// Available options:
9284/// - "RE" - real part of the output
9285/// - "IM" - imaginary part of the output
9286/// - "MAG" - magnitude of the output
9287/// - "PH" - phase of the output
9288
9290{
9291 if (!fft || !fft->GetN() ) {
9292 ::Error("TransformHisto","Invalid FFT transform class");
9293 return nullptr;
9294 }
9295
9296 if (fft->GetNdim()>2){
9297 ::Error("TransformHisto","Only 1d and 2D transform are supported");
9298 return nullptr;
9299 }
9300 Int_t binx,biny;
9301 TString opt = option;
9302 opt.ToUpper();
9303 Int_t *n = fft->GetN();
9304 TH1 *hout=nullptr;
9305 if (h_output) {
9306 hout = h_output;
9307 }
9308 else {
9309 TString name = TString::Format("out_%s", opt.Data());
9310 if (fft->GetNdim()==1)
9311 hout = new TH1D(name, name,n[0], 0, n[0]);
9312 else if (fft->GetNdim()==2)
9313 hout = new TH2D(name, name, n[0], 0, n[0], n[1], 0, n[1]);
9314 }
9315 R__ASSERT(hout != nullptr);
9316 TString type=fft->GetType();
9317 Int_t ind[2];
9318 if (opt.Contains("RE")){
9319 if (type.Contains("2C") || type.Contains("2HC")) {
9320 Double_t re, im;
9321 for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
9322 for (biny=1; biny<=hout->GetNbinsY(); biny++) {
9323 ind[0] = binx-1; ind[1] = biny-1;
9324 fft->GetPointComplex(ind, re, im);
9325 hout->SetBinContent(binx, biny, re);
9326 }
9327 }
9328 } else {
9329 for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
9330 for (biny=1; biny<=hout->GetNbinsY(); biny++) {
9331 ind[0] = binx-1; ind[1] = biny-1;
9332 hout->SetBinContent(binx, biny, fft->GetPointReal(ind));
9333 }
9334 }
9335 }
9336 }
9337 if (opt.Contains("IM")) {
9338 if (type.Contains("2C") || type.Contains("2HC")) {
9339 Double_t re, im;
9340 for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
9341 for (biny=1; biny<=hout->GetNbinsY(); biny++) {
9342 ind[0] = binx-1; ind[1] = biny-1;
9343 fft->GetPointComplex(ind, re, im);
9344 hout->SetBinContent(binx, biny, im);
9345 }
9346 }
9347 } else {
9348 ::Error("TransformHisto","No complex numbers in the output");
9349 return nullptr;
9350 }
9351 }
9352 if (opt.Contains("MA")) {
9353 if (type.Contains("2C") || type.Contains("2HC")) {
9354 Double_t re, im;
9355 for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
9356 for (biny=1; biny<=hout->GetNbinsY(); biny++) {
9357 ind[0] = binx-1; ind[1] = biny-1;
9358 fft->GetPointComplex(ind, re, im);
9359 hout->SetBinContent(binx, biny, TMath::Sqrt(re*re + im*im));
9360 }
9361 }
9362 } else {
9363 for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
9364 for (biny=1; biny<=hout->GetNbinsY(); biny++) {
9365 ind[0] = binx-1; ind[1] = biny-1;
9366 hout->SetBinContent(binx, biny, TMath::Abs(fft->GetPointReal(ind)));
9367 }
9368 }
9369 }
9370 }
9371 if (opt.Contains("PH")) {
9372 if (type.Contains("2C") || type.Contains("2HC")){
9373 Double_t re, im, ph;
9374 for (binx = 1; binx<=hout->GetNbinsX(); binx++){
9375 for (biny=1; biny<=hout->GetNbinsY(); biny++){
9376 ind[0] = binx-1; ind[1] = biny-1;
9377 fft->GetPointComplex(ind, re, im);
9378 if (TMath::Abs(re) > 1e-13){
9379 ph = TMath::ATan(im/re);
9380 //find the correct quadrant
9381 if (re<0 && im<0)
9382 ph -= TMath::Pi();
9383 if (re<0 && im>=0)
9384 ph += TMath::Pi();
9385 } else {
9386 if (TMath::Abs(im) < 1e-13)
9387 ph = 0;
9388 else if (im>0)
9389 ph = TMath::Pi()*0.5;
9390 else
9391 ph = -TMath::Pi()*0.5;
9392 }
9393 hout->SetBinContent(binx, biny, ph);
9394 }
9395 }
9396 } else {
9397 printf("Pure real output, no phase");
9398 return nullptr;
9399 }
9400 }
9401
9402 return hout;
9403}
9404
9405////////////////////////////////////////////////////////////////////////////////
9406/// Raw retrieval of bin content on internal data structure
9407/// see convention for numbering bins in TH1::GetBin
9408
9410{
9411 AbstractMethod("RetrieveBinContent");
9412 return 0;
9413}
9414
9415////////////////////////////////////////////////////////////////////////////////
9416/// Raw update of bin content on internal data structure
9417/// see convention for numbering bins in TH1::GetBin
9418
9420{
9421 AbstractMethod("UpdateBinContent");
9422}
9423
9424////////////////////////////////////////////////////////////////////////////////
9425/// Print value overload
9426
9427std::string cling::printValue(TH1 *val) {
9428 std::ostringstream strm;
9429 strm << cling::printValue((TObject*)val) << " NbinsX: " << val->GetNbinsX();
9430 return strm.str();
9431}
9432
9433//______________________________________________________________________________
9434// TH1C methods
9435// TH1C : histograms with one byte per channel. Maximum bin content = 127
9436//______________________________________________________________________________
9437
9438ClassImp(TH1C);
9439
9440////////////////////////////////////////////////////////////////////////////////
9441/// Constructor.
9442
9443TH1C::TH1C(): TH1(), TArrayC()
9444{
9445 fDimension = 1;
9446 SetBinsLength(3);
9447 if (fgDefaultSumw2) Sumw2();
9448}
9449
9450////////////////////////////////////////////////////////////////////////////////
9451/// Create a 1-Dim histogram with fix bins of type char (one byte per channel)
9452/// (see TH1::TH1 for explanation of parameters)
9453
9454TH1C::TH1C(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
9455: TH1(name,title,nbins,xlow,xup)
9456{
9457 fDimension = 1;
9459
9460 if (xlow >= xup) SetBuffer(fgBufferSize);
9461 if (fgDefaultSumw2) Sumw2();
9462}
9463
9464////////////////////////////////////////////////////////////////////////////////
9465/// Create a 1-Dim histogram with variable bins of type char (one byte per channel)
9466/// (see TH1::TH1 for explanation of parameters)
9467
9468TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
9469: TH1(name,title,nbins,xbins)
9470{
9471 fDimension = 1;
9473 if (fgDefaultSumw2) Sumw2();
9474}
9475
9476////////////////////////////////////////////////////////////////////////////////
9477/// Create a 1-Dim histogram with variable bins of type char (one byte per channel)
9478/// (see TH1::TH1 for explanation of parameters)
9479
9480TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
9481: TH1(name,title,nbins,xbins)
9482{
9483 fDimension = 1;
9485 if (fgDefaultSumw2) Sumw2();
9486}
9487
9488////////////////////////////////////////////////////////////////////////////////
9489/// Destructor.
9490
9492{
9493}
9494
9495////////////////////////////////////////////////////////////////////////////////
9496/// Copy constructor.
9497/// The list of functions is not copied. (Use Clone() if needed)
9498
9499TH1C::TH1C(const TH1C &h1c) : TH1(), TArrayC()
9500{
9501 h1c.TH1C::Copy(*this);
9502}
9503
9504////////////////////////////////////////////////////////////////////////////////
9505/// Increment bin content by 1.
9506/// Passing an out-of-range bin leads to undefined behavior
9507
9508void TH1C::AddBinContent(Int_t bin)
9509{
9510 if (fArray[bin] < 127) fArray[bin]++;
9511}
9512
9513////////////////////////////////////////////////////////////////////////////////
9514/// Increment bin content by w.
9515/// \warning The value of w is cast to `Int_t` before being added.
9516/// Passing an out-of-range bin leads to undefined behavior
9517
9519{
9520 Int_t newval = fArray[bin] + Int_t(w);
9521 if (newval > -128 && newval < 128) {fArray[bin] = Char_t(newval); return;}
9522 if (newval < -127) fArray[bin] = -127;
9523 if (newval > 127) fArray[bin] = 127;
9524}
9525
9526////////////////////////////////////////////////////////////////////////////////
9527/// Copy this to newth1
9528
9529void TH1C::Copy(TObject &newth1) const
9530{
9531 TH1::Copy(newth1);
9532}
9533
9534////////////////////////////////////////////////////////////////////////////////
9535/// Reset.
9536
9538{
9541}
9542
9543////////////////////////////////////////////////////////////////////////////////
9544/// Set total number of bins including under/overflow
9545/// Reallocate bin contents array
9546
9548{
9549 if (n < 0) n = fXaxis.GetNbins() + 2;
9550 fNcells = n;
9551 TArrayC::Set(n);
9552}
9553
9554////////////////////////////////////////////////////////////////////////////////
9555/// Operator =
9556
9557TH1C& TH1C::operator=(const TH1C &h1)
9558{
9559 if (this != &h1)
9560 h1.TH1C::Copy(*this);
9561 return *this;
9562}
9563
9564////////////////////////////////////////////////////////////////////////////////
9565/// Operator *
9566
9568{
9569 TH1C hnew = h1;
9570 hnew.Scale(c1);
9571 hnew.SetDirectory(nullptr);
9572 return hnew;
9573}
9574
9575////////////////////////////////////////////////////////////////////////////////
9576/// Operator +
9577
9578TH1C operator+(const TH1C &h1, const TH1C &h2)
9579{
9580 TH1C hnew = h1;
9581 hnew.Add(&h2,1);
9582 hnew.SetDirectory(nullptr);
9583 return hnew;
9584}
9585
9586////////////////////////////////////////////////////////////////////////////////
9587/// Operator -
9588
9589TH1C operator-(const TH1C &h1, const TH1C &h2)
9590{
9591 TH1C hnew = h1;
9592 hnew.Add(&h2,-1);
9593 hnew.SetDirectory(nullptr);
9594 return hnew;
9595}
9596
9597////////////////////////////////////////////////////////////////////////////////
9598/// Operator *
9599
9600TH1C operator*(const TH1C &h1, const TH1C &h2)
9601{
9602 TH1C hnew = h1;
9603 hnew.Multiply(&h2);
9604 hnew.SetDirectory(nullptr);
9605 return hnew;
9606}
9607
9608////////////////////////////////////////////////////////////////////////////////
9609/// Operator /
9610
9611TH1C operator/(const TH1C &h1, const TH1C &h2)
9612{
9613 TH1C hnew = h1;
9614 hnew.Divide(&h2);
9615 hnew.SetDirectory(nullptr);
9616 return hnew;
9617}
9618
9619//______________________________________________________________________________
9620// TH1S methods
9621// TH1S : histograms with one short per channel. Maximum bin content = 32767
9622//______________________________________________________________________________
9623
9624ClassImp(TH1S);
9625
9626////////////////////////////////////////////////////////////////////////////////
9627/// Constructor.
9628
9629TH1S::TH1S(): TH1(), TArrayS()
9630{
9631 fDimension = 1;
9632 SetBinsLength(3);
9633 if (fgDefaultSumw2) Sumw2();
9634}
9635
9636////////////////////////////////////////////////////////////////////////////////
9637/// Create a 1-Dim histogram with fix bins of type short
9638/// (see TH1::TH1 for explanation of parameters)
9639
9640TH1S::TH1S(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
9641: TH1(name,title,nbins,xlow,xup)
9642{
9643 fDimension = 1;
9645
9646 if (xlow >= xup) SetBuffer(fgBufferSize);
9647 if (fgDefaultSumw2) Sumw2();
9648}
9649
9650////////////////////////////////////////////////////////////////////////////////
9651/// Create a 1-Dim histogram with variable bins of type short
9652/// (see TH1::TH1 for explanation of parameters)
9653
9654TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
9655: TH1(name,title,nbins,xbins)
9656{
9657 fDimension = 1;
9659 if (fgDefaultSumw2) Sumw2();
9660}
9661
9662////////////////////////////////////////////////////////////////////////////////
9663/// Create a 1-Dim histogram with variable bins of type short
9664/// (see TH1::TH1 for explanation of parameters)
9665
9666TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
9667: TH1(name,title,nbins,xbins)
9668{
9669 fDimension = 1;
9671 if (fgDefaultSumw2) Sumw2();
9672}
9673
9674////////////////////////////////////////////////////////////////////////////////
9675/// Destructor.
9676
9678{
9679}
9680
9681////////////////////////////////////////////////////////////////////////////////
9682/// Copy constructor.
9683/// The list of functions is not copied. (Use Clone() if needed)
9684
9685TH1S::TH1S(const TH1S &h1s) : TH1(), TArrayS()
9686{
9687 h1s.TH1S::Copy(*this);
9688}
9689
9690////////////////////////////////////////////////////////////////////////////////
9691/// Increment bin content by 1.
9692/// Passing an out-of-range bin leads to undefined behavior
9693
9694void TH1S::AddBinContent(Int_t bin)
9695{
9696 if (fArray[bin] < 32767) fArray[bin]++;
9697}
9698
9699////////////////////////////////////////////////////////////////////////////////
9700/// Increment bin content by w.
9701/// \warning The value of w is cast to `Int_t` before being added.
9702/// Passing an out-of-range bin leads to undefined behavior
9703
9705{
9706 Int_t newval = fArray[bin] + Int_t(w);
9707 if (newval > -32768 && newval < 32768) {fArray[bin] = Short_t(newval); return;}
9708 if (newval < -32767) fArray[bin] = -32767;
9709 if (newval > 32767) fArray[bin] = 32767;
9710}
9711
9712////////////////////////////////////////////////////////////////////////////////
9713/// Copy this to newth1
9714
9715void TH1S::Copy(TObject &newth1) const
9716{
9717 TH1::Copy(newth1);
9718}
9719
9720////////////////////////////////////////////////////////////////////////////////
9721/// Reset.
9722
9724{
9727}
9728
9729////////////////////////////////////////////////////////////////////////////////
9730/// Set total number of bins including under/overflow
9731/// Reallocate bin contents array
9732
9734{
9735 if (n < 0) n = fXaxis.GetNbins() + 2;
9736 fNcells = n;
9737 TArrayS::Set(n);
9738}
9739
9740////////////////////////////////////////////////////////////////////////////////
9741/// Operator =
9742
9743TH1S& TH1S::operator=(const TH1S &h1)
9744{
9745 if (this != &h1)
9746 h1.TH1S::Copy(*this);
9747 return *this;
9748}
9749
9750////////////////////////////////////////////////////////////////////////////////
9751/// Operator *
9752
9754{
9755 TH1S hnew = h1;
9756 hnew.Scale(c1);
9757 hnew.SetDirectory(nullptr);
9758 return hnew;
9759}
9760
9761////////////////////////////////////////////////////////////////////////////////
9762/// Operator +
9763
9764TH1S operator+(const TH1S &h1, const TH1S &h2)
9765{
9766 TH1S hnew = h1;
9767 hnew.Add(&h2,1);
9768 hnew.SetDirectory(nullptr);
9769 return hnew;
9770}
9771
9772////////////////////////////////////////////////////////////////////////////////
9773/// Operator -
9774
9775TH1S operator-(const TH1S &h1, const TH1S &h2)
9776{
9777 TH1S hnew = h1;
9778 hnew.Add(&h2,-1);
9779 hnew.SetDirectory(nullptr);
9780 return hnew;
9781}
9782
9783////////////////////////////////////////////////////////////////////////////////
9784/// Operator *
9785
9786TH1S operator*(const TH1S &h1, const TH1S &h2)
9787{
9788 TH1S hnew = h1;
9789 hnew.Multiply(&h2);
9790 hnew.SetDirectory(nullptr);
9791 return hnew;
9792}
9793
9794////////////////////////////////////////////////////////////////////////////////
9795/// Operator /
9796
9797TH1S operator/(const TH1S &h1, const TH1S &h2)
9798{
9799 TH1S hnew = h1;
9800 hnew.Divide(&h2);
9801 hnew.SetDirectory(nullptr);
9802 return hnew;
9803}
9804
9805//______________________________________________________________________________
9806// TH1I methods
9807// TH1I : histograms with one int per channel. Maximum bin content = 2147483647
9808// 2147483647 = INT_MAX
9809//______________________________________________________________________________
9810
9811ClassImp(TH1I);
9812
9813////////////////////////////////////////////////////////////////////////////////
9814/// Constructor.
9815
9816TH1I::TH1I(): TH1(), TArrayI()
9817{
9818 fDimension = 1;
9819 SetBinsLength(3);
9820 if (fgDefaultSumw2) Sumw2();
9821}
9822
9823////////////////////////////////////////////////////////////////////////////////
9824/// Create a 1-Dim histogram with fix bins of type integer
9825/// (see TH1::TH1 for explanation of parameters)
9826
9827TH1I::TH1I(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
9828: TH1(name,title,nbins,xlow,xup)
9829{
9830 fDimension = 1;
9832
9833 if (xlow >= xup) SetBuffer(fgBufferSize);
9834 if (fgDefaultSumw2) Sumw2();
9835}
9836
9837////////////////////////////////////////////////////////////////////////////////
9838/// Create a 1-Dim histogram with variable bins of type integer
9839/// (see TH1::TH1 for explanation of parameters)
9840
9841TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
9842: TH1(name,title,nbins,xbins)
9843{
9844 fDimension = 1;
9846 if (fgDefaultSumw2) Sumw2();
9847}
9848
9849////////////////////////////////////////////////////////////////////////////////
9850/// Create a 1-Dim histogram with variable bins of type integer
9851/// (see TH1::TH1 for explanation of parameters)
9852
9853TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
9854: TH1(name,title,nbins,xbins)
9855{
9856 fDimension = 1;
9858 if (fgDefaultSumw2) Sumw2();
9859}
9860
9861////////////////////////////////////////////////////////////////////////////////
9862/// Destructor.
9863
9865{
9866}
9867
9868////////////////////////////////////////////////////////////////////////////////
9869/// Copy constructor.
9870/// The list of functions is not copied. (Use Clone() if needed)
9871
9872TH1I::TH1I(const TH1I &h1i) : TH1(), TArrayI()
9873{
9874 h1i.TH1I::Copy(*this);
9875}
9876
9877////////////////////////////////////////////////////////////////////////////////
9878/// Increment bin content by 1.
9879/// Passing an out-of-range bin leads to undefined behavior
9880
9881void TH1I::AddBinContent(Int_t bin)
9882{
9883 if (fArray[bin] < INT_MAX) fArray[bin]++;
9884}
9885
9886////////////////////////////////////////////////////////////////////////////////
9887/// Increment bin content by w
9888/// \warning The value of w is cast to `Long64_t` before being added.
9889/// Passing an out-of-range bin leads to undefined behavior
9890
9892{
9893 Long64_t newval = fArray[bin] + Long64_t(w);
9894 if (newval > -INT_MAX && newval < INT_MAX) {fArray[bin] = Int_t(newval); return;}
9895 if (newval < -INT_MAX) fArray[bin] = -INT_MAX;
9896 if (newval > INT_MAX) fArray[bin] = INT_MAX;
9897}
9898
9899////////////////////////////////////////////////////////////////////////////////
9900/// Copy this to newth1
9901
9902void TH1I::Copy(TObject &newth1) const
9903{
9904 TH1::Copy(newth1);
9905}
9906
9907////////////////////////////////////////////////////////////////////////////////
9908/// Reset.
9909
9911{
9914}
9915
9916////////////////////////////////////////////////////////////////////////////////
9917/// Set total number of bins including under/overflow
9918/// Reallocate bin contents array
9919
9921{
9922 if (n < 0) n = fXaxis.GetNbins() + 2;
9923 fNcells = n;
9924 TArrayI::Set(n);
9925}
9926
9927////////////////////////////////////////////////////////////////////////////////
9928/// Operator =
9929
9930TH1I& TH1I::operator=(const TH1I &h1)
9931{
9932 if (this != &h1)
9933 h1.TH1I::Copy(*this);
9934 return *this;
9935}
9936
9937
9938////////////////////////////////////////////////////////////////////////////////
9939/// Operator *
9940
9942{
9943 TH1I hnew = h1;
9944 hnew.Scale(c1);
9945 hnew.SetDirectory(nullptr);
9946 return hnew;
9947}
9948
9949////////////////////////////////////////////////////////////////////////////////
9950/// Operator +
9951
9952TH1I operator+(const TH1I &h1, const TH1I &h2)
9953{
9954 TH1I hnew = h1;
9955 hnew.Add(&h2,1);
9956 hnew.SetDirectory(nullptr);
9957 return hnew;
9958}
9959
9960////////////////////////////////////////////////////////////////////////////////
9961/// Operator -
9962
9963TH1I operator-(const TH1I &h1, const TH1I &h2)
9964{
9965 TH1I hnew = h1;
9966 hnew.Add(&h2,-1);
9967 hnew.SetDirectory(nullptr);
9968 return hnew;
9969}
9970
9971////////////////////////////////////////////////////////////////////////////////
9972/// Operator *
9973
9974TH1I operator*(const TH1I &h1, const TH1I &h2)
9975{
9976 TH1I hnew = h1;
9977 hnew.Multiply(&h2);
9978 hnew.SetDirectory(nullptr);
9979 return hnew;
9980}
9981
9982////////////////////////////////////////////////////////////////////////////////
9983/// Operator /
9984
9985TH1I operator/(const TH1I &h1, const TH1I &h2)
9986{
9987 TH1I hnew = h1;
9988 hnew.Divide(&h2);
9989 hnew.SetDirectory(nullptr);
9990 return hnew;
9991}
9992
9993//______________________________________________________________________________
9994// TH1L methods
9995// TH1L : histograms with one long64 per channel. Maximum bin content = 9223372036854775807
9996// 9223372036854775807 = LLONG_MAX
9997//______________________________________________________________________________
9998
9999ClassImp(TH1L);
10000
10001////////////////////////////////////////////////////////////////////////////////
10002/// Constructor.
10003
10004TH1L::TH1L(): TH1(), TArrayL64()
10005{
10006 fDimension = 1;
10007 SetBinsLength(3);
10008 if (fgDefaultSumw2) Sumw2();
10009}
10010
10011////////////////////////////////////////////////////////////////////////////////
10012/// Create a 1-Dim histogram with fix bins of type long64
10013/// (see TH1::TH1 for explanation of parameters)
10014
10015TH1L::TH1L(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
10016: TH1(name,title,nbins,xlow,xup)
10017{
10018 fDimension = 1;
10020
10021 if (xlow >= xup) SetBuffer(fgBufferSize);
10022 if (fgDefaultSumw2) Sumw2();
10023}
10024
10025////////////////////////////////////////////////////////////////////////////////
10026/// Create a 1-Dim histogram with variable bins of type long64
10027/// (see TH1::TH1 for explanation of parameters)
10028
10029TH1L::TH1L(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
10030: TH1(name,title,nbins,xbins)
10031{
10032 fDimension = 1;
10034 if (fgDefaultSumw2) Sumw2();
10035}
10036
10037////////////////////////////////////////////////////////////////////////////////
10038/// Create a 1-Dim histogram with variable bins of type long64
10039/// (see TH1::TH1 for explanation of parameters)
10040
10041TH1L::TH1L(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
10042: TH1(name,title,nbins,xbins)
10043{
10044 fDimension = 1;
10046 if (fgDefaultSumw2) Sumw2();
10047}
10048
10049////////////////////////////////////////////////////////////////////////////////
10050/// Destructor.
10051
10053{
10054}
10055
10056////////////////////////////////////////////////////////////////////////////////
10057/// Copy constructor.
10058/// The list of functions is not copied. (Use Clone() if needed)
10059
10060TH1L::TH1L(const TH1L &h1l) : TH1(), TArrayL64()
10061{
10062 h1l.TH1L::Copy(*this);
10063}
10064
10065////////////////////////////////////////////////////////////////////////////////
10066/// Increment bin content by 1.
10067/// Passing an out-of-range bin leads to undefined behavior
10068
10069void TH1L::AddBinContent(Int_t bin)
10070{
10071 if (fArray[bin] < LLONG_MAX) fArray[bin]++;
10072}
10073
10074////////////////////////////////////////////////////////////////////////////////
10075/// Increment bin content by w.
10076/// \warning The value of w is cast to `Long64_t` before being added.
10077/// Passing an out-of-range bin leads to undefined behavior
10078
10080{
10081 Long64_t newval = fArray[bin] + Long64_t(w);
10082 if (newval > -LLONG_MAX && newval < LLONG_MAX) {fArray[bin] = newval; return;}
10083 if (newval < -LLONG_MAX) fArray[bin] = -LLONG_MAX;
10084 if (newval > LLONG_MAX) fArray[bin] = LLONG_MAX;
10085}
10086
10087////////////////////////////////////////////////////////////////////////////////
10088/// Copy this to newth1
10089
10090void TH1L::Copy(TObject &newth1) const
10091{
10092 TH1::Copy(newth1);
10093}
10094
10095////////////////////////////////////////////////////////////////////////////////
10096/// Reset.
10097
10099{
10102}
10103
10104////////////////////////////////////////////////////////////////////////////////
10105/// Set total number of bins including under/overflow
10106/// Reallocate bin contents array
10107
10109{
10110 if (n < 0) n = fXaxis.GetNbins() + 2;
10111 fNcells = n;
10113}
10114
10115////////////////////////////////////////////////////////////////////////////////
10116/// Operator =
10117
10118TH1L& TH1L::operator=(const TH1L &h1)
10119{
10120 if (this != &h1)
10121 h1.TH1L::Copy(*this);
10122 return *this;
10123}
10124
10125
10126////////////////////////////////////////////////////////////////////////////////
10127/// Operator *
10128
10130{
10131 TH1L hnew = h1;
10132 hnew.Scale(c1);
10133 hnew.SetDirectory(nullptr);
10134 return hnew;
10135}
10136
10137////////////////////////////////////////////////////////////////////////////////
10138/// Operator +
10139
10140TH1L operator+(const TH1L &h1, const TH1L &h2)
10141{
10142 TH1L hnew = h1;
10143 hnew.Add(&h2,1);
10144 hnew.SetDirectory(nullptr);
10145 return hnew;
10146}
10147
10148////////////////////////////////////////////////////////////////////////////////
10149/// Operator -
10150
10151TH1L operator-(const TH1L &h1, const TH1L &h2)
10152{
10153 TH1L hnew = h1;
10154 hnew.Add(&h2,-1);
10155 hnew.SetDirectory(nullptr);
10156 return hnew;
10157}
10158
10159////////////////////////////////////////////////////////////////////////////////
10160/// Operator *
10161
10162TH1L operator*(const TH1L &h1, const TH1L &h2)
10163{
10164 TH1L hnew = h1;
10165 hnew.Multiply(&h2);
10166 hnew.SetDirectory(nullptr);
10167 return hnew;
10168}
10169
10170////////////////////////////////////////////////////////////////////////////////
10171/// Operator /
10172
10173TH1L operator/(const TH1L &h1, const TH1L &h2)
10174{
10175 TH1L hnew = h1;
10176 hnew.Divide(&h2);
10177 hnew.SetDirectory(nullptr);
10178 return hnew;
10179}
10180
10181//______________________________________________________________________________
10182// TH1F methods
10183// TH1F : histograms with one float per channel. Maximum precision 7 digits, maximum integer bin content = +/-16777216
10184//______________________________________________________________________________
10185
10186ClassImp(TH1F);
10187
10188////////////////////////////////////////////////////////////////////////////////
10189/// Constructor.
10190
10191TH1F::TH1F(): TH1(), TArrayF()
10192{
10193 fDimension = 1;
10194 SetBinsLength(3);
10195 if (fgDefaultSumw2) Sumw2();
10196}
10197
10198////////////////////////////////////////////////////////////////////////////////
10199/// Create a 1-Dim histogram with fix bins of type float
10200/// (see TH1::TH1 for explanation of parameters)
10201
10202TH1F::TH1F(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
10203: TH1(name,title,nbins,xlow,xup)
10204{
10205 fDimension = 1;
10207
10208 if (xlow >= xup) SetBuffer(fgBufferSize);
10209 if (fgDefaultSumw2) Sumw2();
10210}
10211
10212////////////////////////////////////////////////////////////////////////////////
10213/// Create a 1-Dim histogram with variable bins of type float
10214/// (see TH1::TH1 for explanation of parameters)
10215
10216TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
10217: TH1(name,title,nbins,xbins)
10218{
10219 fDimension = 1;
10221 if (fgDefaultSumw2) Sumw2();
10222}
10223
10224////////////////////////////////////////////////////////////////////////////////
10225/// Create a 1-Dim histogram with variable bins of type float
10226/// (see TH1::TH1 for explanation of parameters)
10227
10228TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
10229: TH1(name,title,nbins,xbins)
10230{
10231 fDimension = 1;
10233 if (fgDefaultSumw2) Sumw2();
10234}
10235
10236////////////////////////////////////////////////////////////////////////////////
10237/// Create a histogram from a TVectorF
10238/// by default the histogram name is "TVectorF" and title = ""
10239
10240TH1F::TH1F(const TVectorF &v)
10241: TH1("TVectorF","",v.GetNrows(),0,v.GetNrows())
10242{
10244 fDimension = 1;
10245 Int_t ivlow = v.GetLwb();
10246 for (Int_t i=0;i<fNcells-2;i++) {
10247 SetBinContent(i+1,v(i+ivlow));
10248 }
10250 if (fgDefaultSumw2) Sumw2();
10251}
10252
10253////////////////////////////////////////////////////////////////////////////////
10254/// Copy Constructor.
10255/// The list of functions is not copied. (Use Clone() if needed)
10256
10257TH1F::TH1F(const TH1F &h1f) : TH1(), TArrayF()
10258{
10259 h1f.TH1F::Copy(*this);
10260}
10261
10262////////////////////////////////////////////////////////////////////////////////
10263/// Destructor.
10264
10266{
10267}
10268
10269////////////////////////////////////////////////////////////////////////////////
10270/// Copy this to newth1.
10271
10272void TH1F::Copy(TObject &newth1) const
10273{
10274 TH1::Copy(newth1);
10275}
10276
10277////////////////////////////////////////////////////////////////////////////////
10278/// Reset.
10279
10281{
10284}
10285
10286////////////////////////////////////////////////////////////////////////////////
10287/// Set total number of bins including under/overflow
10288/// Reallocate bin contents array
10289
10291{
10292 if (n < 0) n = fXaxis.GetNbins() + 2;
10293 fNcells = n;
10294 TArrayF::Set(n);
10295}
10296
10297////////////////////////////////////////////////////////////////////////////////
10298/// Operator =
10299
10300TH1F& TH1F::operator=(const TH1F &h1f)
10301{
10302 if (this != &h1f)
10303 h1f.TH1F::Copy(*this);
10304 return *this;
10305}
10306
10307////////////////////////////////////////////////////////////////////////////////
10308/// Operator *
10309
10311{
10312 TH1F hnew = h1;
10313 hnew.Scale(c1);
10314 hnew.SetDirectory(nullptr);
10315 return hnew;
10316}
10317
10318////////////////////////////////////////////////////////////////////////////////
10319/// Operator +
10320
10321TH1F operator+(const TH1F &h1, const TH1F &h2)
10322{
10323 TH1F hnew = h1;
10324 hnew.Add(&h2,1);
10325 hnew.SetDirectory(nullptr);
10326 return hnew;
10327}
10328
10329////////////////////////////////////////////////////////////////////////////////
10330/// Operator -
10331
10332TH1F operator-(const TH1F &h1, const TH1F &h2)
10333{
10334 TH1F hnew = h1;
10335 hnew.Add(&h2,-1);
10336 hnew.SetDirectory(nullptr);
10337 return hnew;
10338}
10339
10340////////////////////////////////////////////////////////////////////////////////
10341/// Operator *
10342
10343TH1F operator*(const TH1F &h1, const TH1F &h2)
10344{
10345 TH1F hnew = h1;
10346 hnew.Multiply(&h2);
10347 hnew.SetDirectory(nullptr);
10348 return hnew;
10349}
10350
10351////////////////////////////////////////////////////////////////////////////////
10352/// Operator /
10353
10354TH1F operator/(const TH1F &h1, const TH1F &h2)
10355{
10356 TH1F hnew = h1;
10357 hnew.Divide(&h2);
10358 hnew.SetDirectory(nullptr);
10359 return hnew;
10360}
10361
10362//______________________________________________________________________________
10363// TH1D methods
10364// TH1D : histograms with one double per channel. Maximum precision 14 digits, maximum integer bin content = +/-9007199254740992
10365//______________________________________________________________________________
10366
10367ClassImp(TH1D);
10368
10369////////////////////////////////////////////////////////////////////////////////
10370/// Constructor.
10371
10372TH1D::TH1D(): TH1(), TArrayD()
10373{
10374 fDimension = 1;
10375 SetBinsLength(3);
10376 if (fgDefaultSumw2) Sumw2();
10377}
10378
10379////////////////////////////////////////////////////////////////////////////////
10380/// Create a 1-Dim histogram with fix bins of type double
10381/// (see TH1::TH1 for explanation of parameters)
10382
10383TH1D::TH1D(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
10384: TH1(name,title,nbins,xlow,xup)
10385{
10386 fDimension = 1;
10388
10389 if (xlow >= xup) SetBuffer(fgBufferSize);
10390 if (fgDefaultSumw2) Sumw2();
10391}
10392
10393////////////////////////////////////////////////////////////////////////////////
10394/// Create a 1-Dim histogram with variable bins of type double
10395/// (see TH1::TH1 for explanation of parameters)
10396
10397TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
10398: TH1(name,title,nbins,xbins)
10399{
10400 fDimension = 1;
10402 if (fgDefaultSumw2) Sumw2();
10403}
10404
10405////////////////////////////////////////////////////////////////////////////////
10406/// Create a 1-Dim histogram with variable bins of type double
10407/// (see TH1::TH1 for explanation of parameters)
10408
10409TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
10410: TH1(name,title,nbins,xbins)
10411{
10412 fDimension = 1;
10414 if (fgDefaultSumw2) Sumw2();
10415}
10416
10417////////////////////////////////////////////////////////////////////////////////
10418/// Create a histogram from a TVectorD
10419/// by default the histogram name is "TVectorD" and title = ""
10420
10421TH1D::TH1D(const TVectorD &v)
10422: TH1("TVectorD","",v.GetNrows(),0,v.GetNrows())
10423{
10425 fDimension = 1;
10426 Int_t ivlow = v.GetLwb();
10427 for (Int_t i=0;i<fNcells-2;i++) {
10428 SetBinContent(i+1,v(i+ivlow));
10429 }
10431 if (fgDefaultSumw2) Sumw2();
10432}
10433
10434////////////////////////////////////////////////////////////////////////////////
10435/// Destructor.
10436
10438{
10439}
10440
10441////////////////////////////////////////////////////////////////////////////////
10442/// Constructor.
10443
10444TH1D::TH1D(const TH1D &h1d) : TH1(), TArrayD()
10445{
10446 // intentially call virtual method to warn if TProfile is copying
10447 h1d.Copy(*this);
10448}
10449
10450////////////////////////////////////////////////////////////////////////////////
10451/// Copy this to newth1
10452
10453void TH1D::Copy(TObject &newth1) const
10454{
10455 TH1::Copy(newth1);
10456}
10457
10458////////////////////////////////////////////////////////////////////////////////
10459/// Reset.
10460
10462{
10465}
10466
10467////////////////////////////////////////////////////////////////////////////////
10468/// Set total number of bins including under/overflow
10469/// Reallocate bin contents array
10470
10472{
10473 if (n < 0) n = fXaxis.GetNbins() + 2;
10474 fNcells = n;
10475 TArrayD::Set(n);
10476}
10477
10478////////////////////////////////////////////////////////////////////////////////
10479/// Operator =
10480
10481TH1D& TH1D::operator=(const TH1D &h1d)
10482{
10483 // intentially call virtual method to warn if TProfile is copying
10484 if (this != &h1d)
10485 h1d.Copy(*this);
10486 return *this;
10487}
10488
10489////////////////////////////////////////////////////////////////////////////////
10490/// Operator *
10491
10493{
10494 TH1D hnew = h1;
10495 hnew.Scale(c1);
10496 hnew.SetDirectory(nullptr);
10497 return hnew;
10498}
10499
10500////////////////////////////////////////////////////////////////////////////////
10501/// Operator +
10502
10503TH1D operator+(const TH1D &h1, const TH1D &h2)
10504{
10505 TH1D hnew = h1;
10506 hnew.Add(&h2,1);
10507 hnew.SetDirectory(nullptr);
10508 return hnew;
10509}
10510
10511////////////////////////////////////////////////////////////////////////////////
10512/// Operator -
10513
10514TH1D operator-(const TH1D &h1, const TH1D &h2)
10515{
10516 TH1D hnew = h1;
10517 hnew.Add(&h2,-1);
10518 hnew.SetDirectory(nullptr);
10519 return hnew;
10520}
10521
10522////////////////////////////////////////////////////////////////////////////////
10523/// Operator *
10524
10525TH1D operator*(const TH1D &h1, const TH1D &h2)
10526{
10527 TH1D hnew = h1;
10528 hnew.Multiply(&h2);
10529 hnew.SetDirectory(nullptr);
10530 return hnew;
10531}
10532
10533////////////////////////////////////////////////////////////////////////////////
10534/// Operator /
10535
10536TH1D operator/(const TH1D &h1, const TH1D &h2)
10537{
10538 TH1D hnew = h1;
10539 hnew.Divide(&h2);
10540 hnew.SetDirectory(nullptr);
10541 return hnew;
10542}
10543
10544////////////////////////////////////////////////////////////////////////////////
10545///return pointer to histogram with name
10546///hid if id >=0
10547///h_id if id <0
10548
10549TH1 *R__H(Int_t hid)
10550{
10551 TString hname;
10552 if(hid >= 0) hname.Form("h%d",hid);
10553 else hname.Form("h_%d",hid);
10554 return (TH1*)gDirectory->Get(hname);
10555}
10556
10557////////////////////////////////////////////////////////////////////////////////
10558///return pointer to histogram with name hname
10559
10560TH1 *R__H(const char * hname)
10561{
10562 return (TH1*)gDirectory->Get(hname);
10563}
10564
10565
10566/// \fn void TH1::SetBarOffset(Float_t offset)
10567/// Set the bar offset as fraction of the bin width for drawing mode "B".
10568/// This shifts bars to the right on the x axis, and helps to draw bars next to each other.
10569/// \see THistPainter, SetBarWidth()
10570
10571/// \fn void TH1::SetBarWidth(Float_t width)
10572/// Set the width of bars as fraction of the bin width for drawing mode "B".
10573/// This allows for making bars narrower than the bin width. With SetBarOffset(), this helps to draw multiple bars next to each other.
10574/// \see THistPainter, SetBarOffset()
#define b(i)
Definition RSha256.hxx:100
#define c(i)
Definition RSha256.hxx:101
#define a(i)
Definition RSha256.hxx:99
#define s1(x)
Definition RSha256.hxx:91
#define h(i)
Definition RSha256.hxx:106
#define e(i)
Definition RSha256.hxx:103
short Style_t
Definition RtypesCore.h:89
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
short Color_t
Definition RtypesCore.h:92
short Version_t
Definition RtypesCore.h:65
char Char_t
Definition RtypesCore.h:37
float Float_t
Definition RtypesCore.h:57
short Short_t
Definition RtypesCore.h:39
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
long long Long64_t
Definition RtypesCore.h:80
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define BIT(n)
Definition Rtypes.h:85
#define ClassImp(name)
Definition Rtypes.h:377
#define gDirectory
Definition TDirectory.h:384
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
#define R__ASSERT(e)
Definition TError.h:118
Option_t Option_t option
Option_t Option_t SetLineWidth
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t SetFillStyle
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t del
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t np
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Option_t Option_t SetLineColor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t SetFillColor
Option_t Option_t SetMarkerStyle
Option_t Option_t width
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition TGX11.cxx:110
static bool IsEquidistantBinning(const TAxis &axis)
Test if the binning is equidistant.
Definition TH1.cxx:5846
void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail)
Least square linear fit without weights.
Definition TH1.cxx:4794
void H1InitGaus()
Compute Initial values of parameters for a gaussian.
Definition TH1.cxx:4629
void H1InitExpo()
Compute Initial values of parameters for an exponential.
Definition TH1.cxx:4685
TH1C operator+(const TH1C &h1, const TH1C &h2)
Operator +.
Definition TH1.cxx:9576
TH1C operator-(const TH1C &h1, const TH1C &h2)
Operator -.
Definition TH1.cxx:9587
TH1C operator/(const TH1C &h1, const TH1C &h2)
Operator /.
Definition TH1.cxx:9609
void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b)
Extracted from CERN Program library routine DSEQN.
Definition TH1.cxx:4840
static Bool_t AlmostEqual(Double_t a, Double_t b, Double_t epsilon=0.00000001)
Test if two double are almost equal.
Definition TH1.cxx:5829
static Bool_t AlmostInteger(Double_t a, Double_t epsilon=0.00000001)
Test if a double is almost an integer.
Definition TH1.cxx:5837
TF1 * gF1
Definition TH1.cxx:581
TH1 * R__H(Int_t hid)
return pointer to histogram with name hid if id >=0 h_id if id <0
Definition TH1.cxx:10547
TH1C operator*(Double_t c1, const TH1C &h1)
Operator *.
Definition TH1.cxx:9565
void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a)
Least squares lpolynomial fitting without weights.
Definition TH1.cxx:4735
void H1InitPolynom()
Compute Initial values of parameters for a polynom.
Definition TH1.cxx:4705
float xmin
int nentries
float * q
float ymin
float xmax
float ymax
#define gInterpreter
Int_t gDebug
Definition TROOT.cxx:597
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:406
R__EXTERN TRandom * gRandom
Definition TRandom.h:62
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2503
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
#define R__LOCKGUARD(mutex)
#define gPad
#define R__WRITE_LOCKGUARD(mutex)
Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y ...
Definition BinData.h:52
class describing the range in the coordinates it supports multiple range in a coordinate.
Definition DataRange.h:35
void AndersonDarling2SamplesTest(Double_t &pvalue, Double_t &testStat) const
Performs the Anderson-Darling 2-Sample Test.
Definition GoFTest.cxx:646
Array of chars or bytes (8 bits per element).
Definition TArrayC.h:27
Char_t * fArray
Definition TArrayC.h:30
void Reset(Char_t val=0)
Definition TArrayC.h:47
void Set(Int_t n) override
Set size of this array to n chars.
Definition TArrayC.cxx:105
Array of doubles (64 bits per element).
Definition TArrayD.h:27
Double_t GetAt(Int_t i) const override
Definition TArrayD.h:45
Double_t * fArray
Definition TArrayD.h:30
void Streamer(TBuffer &) override
Stream a TArrayD object.
Definition TArrayD.cxx:149
void Copy(TArrayD &array) const
Definition TArrayD.h:42
void Set(Int_t n) override
Set size of this array to n doubles.
Definition TArrayD.cxx:106
const Double_t * GetArray() const
Definition TArrayD.h:43
void Reset()
Definition TArrayD.h:47
Array of floats (32 bits per element).
Definition TArrayF.h:27
void Reset()
Definition TArrayF.h:47
void Set(Int_t n) override
Set size of this array to n floats.
Definition TArrayF.cxx:105
Array of integers (32 bits per element).
Definition TArrayI.h:27
Int_t * fArray
Definition TArrayI.h:30
void Set(Int_t n) override
Set size of this array to n ints.
Definition TArrayI.cxx:105
void Reset()
Definition TArrayI.h:47
Array of long64s (64 bits per element).
Definition TArrayL64.h:27
Long64_t * fArray
Definition TArrayL64.h:30
void Set(Int_t n) override
Set size of this array to n long64s.
void Reset()
Definition TArrayL64.h:47
Array of shorts (16 bits per element).
Definition TArrayS.h:27
void Set(Int_t n) override
Set size of this array to n shorts.
Definition TArrayS.cxx:105
void Reset()
Definition TArrayS.h:47
Short_t * fArray
Definition TArrayS.h:30
Abstract array base class.
Definition TArray.h:31
Int_t fN
Definition TArray.h:38
virtual void Set(Int_t n)=0
Int_t GetSize() const
Definition TArray.h:47
virtual Color_t GetTitleColor() const
Definition TAttAxis.h:46
virtual Color_t GetLabelColor() const
Definition TAttAxis.h:38
virtual Int_t GetNdivisions() const
Definition TAttAxis.h:36
virtual Color_t GetAxisColor() const
Definition TAttAxis.h:37
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title.
Definition TAttAxis.cxx:298
virtual Style_t GetTitleFont() const
Definition TAttAxis.h:47
virtual Float_t GetLabelOffset() const
Definition TAttAxis.h:40
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition TAttAxis.cxx:160
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels.
Definition TAttAxis.cxx:203
virtual Style_t GetLabelFont() const
Definition TAttAxis.h:39
virtual void SetTitleFont(Style_t font=62)
Set the title font.
Definition TAttAxis.cxx:327
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels.
Definition TAttAxis.cxx:191
virtual void SetLabelFont(Style_t font=62)
Set labels' font.
Definition TAttAxis.cxx:180
virtual void SetTitleSize(Float_t size=0.04)
Set size of axis title.
Definition TAttAxis.cxx:309
virtual void SetTitleColor(Color_t color=1)
Set color of axis title.
Definition TAttAxis.cxx:318
virtual Float_t GetTitleSize() const
Definition TAttAxis.h:44
virtual Float_t GetLabelSize() const
Definition TAttAxis.h:41
virtual Float_t GetTickLength() const
Definition TAttAxis.h:45
virtual void ResetAttAxis(Option_t *option="")
Reset axis attributes.
Definition TAttAxis.cxx:79
virtual Float_t GetTitleOffset() const
Definition TAttAxis.h:43
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length.
Definition TAttAxis.cxx:284
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition TAttAxis.cxx:233
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition TAttAxis.cxx:170
Fill Area Attributes class.
Definition TAttFill.h:19
virtual void Streamer(TBuffer &)
virtual Color_t GetFillColor() const
Return the fill area color.
Definition TAttFill.h:30
void Copy(TAttFill &attfill) const
Copy this fill attributes to a new TAttFill.
Definition TAttFill.cxx:207
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition TAttFill.h:31
virtual void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition TAttFill.cxx:239
Line Attributes class.
Definition TAttLine.h:18
virtual void Streamer(TBuffer &)
virtual Color_t GetLineColor() const
Return the line color.
Definition TAttLine.h:33
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition TAttLine.h:42
virtual Width_t GetLineWidth() const
Return the line width.
Definition TAttLine.h:35
virtual Style_t GetLineStyle() const
Return the line style.
Definition TAttLine.h:34
void Copy(TAttLine &attline) const
Copy this line attributes to a new TAttLine.
Definition TAttLine.cxx:177
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition TAttLine.cxx:275
Marker Attributes class.
Definition TAttMarker.h:19
virtual void SaveMarkerAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1)
Save line attributes as C++ statement(s) on output stream out.
virtual Style_t GetMarkerStyle() const
Return the marker style.
Definition TAttMarker.h:32
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition TAttMarker.h:38
virtual Color_t GetMarkerColor() const
Return the marker color.
Definition TAttMarker.h:31
virtual Size_t GetMarkerSize() const
Return the marker size.
Definition TAttMarker.h:33
virtual void SetMarkerStyle(Style_t mstyle=1)
Set the marker style.
Definition TAttMarker.h:40
void Copy(TAttMarker &attmarker) const
Copy this marker attributes to a new TAttMarker.
virtual void Streamer(TBuffer &)
virtual void SetMarkerSize(Size_t msize=1)
Set the marker size.
Definition TAttMarker.h:45
Class to manage histogram axis.
Definition TAxis.h:31
virtual void GetCenter(Double_t *center) const
Return an array with the center of all bins.
Definition TAxis.cxx:553
virtual Bool_t GetTimeDisplay() const
Definition TAxis.h:131
Bool_t IsAlphanumeric() const
Definition TAxis.h:88
const char * GetTitle() const override
Returns title of object.
Definition TAxis.h:135
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition TAxis.cxx:478
Bool_t CanExtend() const
Definition TAxis.h:86
virtual void SetParent(TObject *obj)
Definition TAxis.h:167
const TArrayD * GetXbins() const
Definition TAxis.h:136
void SetCanExtend(Bool_t canExtend)
Definition TAxis.h:90
void Copy(TObject &axis) const override
Copy axis structure to another axis.
Definition TAxis.cxx:216
Double_t GetXmax() const
Definition TAxis.h:140
@ kLabelsUp
Definition TAxis.h:74
@ kLabelsDown
Definition TAxis.h:73
@ kLabelsHori
Definition TAxis.h:71
@ kAxisRange
Definition TAxis.h:65
@ kLabelsVert
Definition TAxis.h:72
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition TAxis.cxx:440
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition TAxis.cxx:293
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition TAxis.cxx:518
virtual void SetTimeDisplay(Int_t value)
Definition TAxis.h:171
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition TAxis.cxx:794
virtual Int_t FindFixBin(Double_t x) const
Find bin number corresponding to abscissa x.
Definition TAxis.cxx:419
void SaveAttributes(std::ostream &out, const char *name, const char *subname) override
Save axis attributes as C++ statement(s) on output stream out.
Definition TAxis.cxx:710
Int_t GetLast() const
Return last bin on the axis i.e.
Definition TAxis.cxx:469
virtual void SetLimits(Double_t xmin, Double_t xmax)
Definition TAxis.h:164
Double_t GetXmin() const
Definition TAxis.h:139
void Streamer(TBuffer &) override
Stream an object of class TAxis.
Definition TAxis.cxx:1216
Int_t GetNbins() const
Definition TAxis.h:125
virtual void GetLowEdge(Double_t *edge) const
Return an array with the low edge of all bins.
Definition TAxis.cxx:562
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition TAxis.cxx:1052
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition TAxis.cxx:540
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition TAxis.cxx:528
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition TAxis.cxx:458
THashList * GetLabels() const
Definition TAxis.h:121
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
Buffer base class used for serializing objects.
Definition TBuffer.h:43
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition TClass.cxx:4978
ROOT::NewFunc_t GetNew() const
Return the wrapper around new ThisClass().
Definition TClass.cxx:7447
Collection abstract base class.
Definition TCollection.h:65
virtual bool UseRWLock(Bool_t enable=true)
Set this collection to use a RW lock upon access, making it thread safe.
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
virtual Bool_t IsEmpty() const
TObject * Clone(const char *newname="") const override
Make a clone of an collection using the Streamer facility.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Describe directory structure in memory.
Definition TDirectory.h:45
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
1-Dim function class
Definition TF1.h:233
static void RejectPoint(Bool_t reject=kTRUE)
Static function to set the global flag to reject points the fgRejectPoint global flag is tested by al...
Definition TF1.cxx:3683
virtual TH1 * GetHistogram() const
Return a pointer to the histogram used to visualise the function Note that this histogram is managed ...
Definition TF1.cxx:1586
static TClass * Class()
virtual Int_t GetNpar() const
Definition TF1.h:507
virtual Double_t Integral(Double_t a, Double_t b, Double_t epsrel=1.e-12)
IntegralOneDim or analytical integral.
Definition TF1.cxx:2531
virtual void InitArgs(const Double_t *x, const Double_t *params)
Initialize parameters addresses.
Definition TF1.cxx:2482
virtual void GetRange(Double_t *xmin, Double_t *xmax) const
Return range of a generic N-D function.
Definition TF1.cxx:2281
virtual Double_t EvalPar(const Double_t *x, const Double_t *params=nullptr)
Evaluate function with given coordinates and parameters.
Definition TF1.cxx:1470
virtual void SetParLimits(Int_t ipar, Double_t parmin, Double_t parmax)
Set lower and upper limits for parameter ipar.
Definition TF1.cxx:3507
static Bool_t RejectedPoint()
See TF1::RejectPoint above.
Definition TF1.cxx:3692
virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const
Evaluate this function.
Definition TF1.cxx:1441
virtual void SetParameter(Int_t param, Double_t value)
Definition TF1.h:660
virtual Bool_t IsInside(const Double_t *x) const
return kTRUE if the point is inside the function range
Definition TF1.h:624
A 2-Dim function with parameters.
Definition TF2.h:29
A 3-Dim function with parameters.
Definition TF3.h:28
Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointe...
1-D histogram with a byte per channel (see TH1 documentation)
Definition TH1.h:457
~TH1C() override
Destructor.
Definition TH1.cxx:9489
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:9545
TH1C & operator=(const TH1C &h1)
Operator =.
Definition TH1.cxx:9555
TH1C()
Constructor.
Definition TH1.cxx:9441
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:9527
void AddBinContent(Int_t bin) override
Increment bin content by 1.
Definition TH1.cxx:9506
void Reset(Option_t *option="") override
Reset.
Definition TH1.cxx:9535
1-D histogram with a double per channel (see TH1 documentation)
Definition TH1.h:669
~TH1D() override
Destructor.
Definition TH1.cxx:10435
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:10469
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:10451
TH1D()
Constructor.
Definition TH1.cxx:10370
TH1D & operator=(const TH1D &h1)
Operator =.
Definition TH1.cxx:10479
void Reset(Option_t *option="") override
Reset.
Definition TH1.cxx:10459
1-D histogram with a float per channel (see TH1 documentation)
Definition TH1.h:621
Double_t RetrieveBinContent(Int_t bin) const override
Raw retrieval of bin content on internal data structure see convention for numbering bins in TH1::Get...
Definition TH1.h:655
TH1F & operator=(const TH1F &h1)
Operator =.
Definition TH1.cxx:10298
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:10270
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:10288
~TH1F() override
Destructor.
Definition TH1.cxx:10263
TH1F()
Constructor.
Definition TH1.cxx:10189
1-D histogram with an int per channel (see TH1 documentation)
Definition TH1.h:539
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:9918
void AddBinContent(Int_t bin) override
Increment bin content by 1.
Definition TH1.cxx:9879
~TH1I() override
Destructor.
Definition TH1.cxx:9862
TH1I()
Constructor.
Definition TH1.cxx:9814
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:9900
TH1I & operator=(const TH1I &h1)
Operator =.
Definition TH1.cxx:9928
1-D histogram with a long64 per channel (see TH1 documentation)
Definition TH1.h:580
TH1L & operator=(const TH1L &h1)
Operator =.
Definition TH1.cxx:10116
void AddBinContent(Int_t bin) override
Increment bin content by 1.
Definition TH1.cxx:10067
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:10106
~TH1L() override
Destructor.
Definition TH1.cxx:10050
TH1L()
Constructor.
Definition TH1.cxx:10002
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:10088
1-D histogram with a short per channel (see TH1 documentation)
Definition TH1.h:498
TH1S & operator=(const TH1S &h1)
Operator =.
Definition TH1.cxx:9741
void Copy(TObject &hnew) const override
Copy this to newth1.
Definition TH1.cxx:9713
TH1S()
Constructor.
Definition TH1.cxx:9627
void SetBinsLength(Int_t n=-1) override
Set total number of bins including under/overflow Reallocate bin contents array.
Definition TH1.cxx:9731
~TH1S() override
Destructor.
Definition TH1.cxx:9675
void AddBinContent(Int_t bin) override
Increment bin content by 1.
Definition TH1.cxx:9692
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
~TH1() override
Histogram default destructor.
Definition TH1.cxx:643
virtual void SetError(const Double_t *error)
Replace bin errors by values in array error.
Definition TH1.cxx:8919
virtual void SetDirectory(TDirectory *dir)
By default, when a histogram is created, it is added to the list of histogram objects in the current ...
Definition TH1.cxx:8905
virtual void FitPanel()
Display a panel with all histogram fit options.
Definition TH1.cxx:4284
Double_t * fBuffer
[fBufferSize] entry buffer
Definition TH1.h:108
virtual Int_t AutoP2FindLimits(Double_t min, Double_t max)
Buffer-based estimate of the histogram range using the power of 2 algorithm.
Definition TH1.cxx:1343
virtual Double_t GetEffectiveEntries() const
Number of effective entries of the histogram.
Definition TH1.cxx:4448
char * GetObjectInfo(Int_t px, Int_t py) const override
Redefines TObject::GetObjectInfo.
Definition TH1.cxx:4479
virtual void Smooth(Int_t ntimes=1, Option_t *option="")
Smooth bin contents of this histogram.
Definition TH1.cxx:6847
virtual Double_t GetBinCenter(Int_t bin) const
Return bin center for 1D histogram.
Definition TH1.cxx:9109
virtual void Rebuild(Option_t *option="")
Using the current bin info, recompute the arrays for contents and errors.
Definition TH1.cxx:7055
virtual void SetBarOffset(Float_t offset=0.25)
Set the bar offset as fraction of the bin width for drawing mode "B".
Definition TH1.h:364
static Bool_t fgStatOverflows
! Flag to use under/overflows in statistics
Definition TH1.h:117
virtual Int_t FindLastBinAbove(Double_t threshold=0, Int_t axis=1, Int_t firstBin=1, Int_t lastBin=-1) const
Find last bin with content > threshold for axis (1=x, 2=y, 3=z) if no bins with content > threshold i...
Definition TH1.cxx:3797
TAxis * GetZaxis()
Definition TH1.h:326
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a line.
Definition TH1.cxx:2823
virtual Bool_t Multiply(TF1 *f1, Double_t c1=1)
Performs the operation:
Definition TH1.cxx:6017
@ kXaxis
Definition TH1.h:73
@ kNoAxis
NOTE: Must always be 0 !!!
Definition TH1.h:72
@ kZaxis
Definition TH1.h:75
@ kYaxis
Definition TH1.h:74
Int_t fNcells
Number of bins(1D), cells (2D) +U/Overflows.
Definition TH1.h:89
virtual void GetStats(Double_t *stats) const
fill the array stats from the contents of this histogram The array stats must be correctly dimensione...
Definition TH1.cxx:7801
void Copy(TObject &hnew) const override
Copy this histogram structure to newth1.
Definition TH1.cxx:2671
void SetTitle(const char *title) override
Change/set the title.
Definition TH1.cxx:6686
Double_t fTsumw
Total Sum of weights.
Definition TH1.h:96
virtual Float_t GetBarWidth() const
Definition TH1.h:257
Double_t fTsumw2
Total Sum of squares of weights.
Definition TH1.h:97
static void StatOverflows(Bool_t flag=kTRUE)
if flag=kTRUE, underflows and overflows are used by the Fill functions in the computation of statisti...
Definition TH1.cxx:6893
virtual Float_t GetBarOffset() const
Definition TH1.h:256
TList * fFunctions
->Pointer to list of functions (fits and user)
Definition TH1.h:106
static Bool_t fgAddDirectory
! Flag to add histograms to the directory
Definition TH1.h:116
static int CheckConsistency(const TH1 *h1, const TH1 *h2)
Check histogram compatibility.
Definition TH1.cxx:1677
static TClass * Class()
static Int_t GetDefaultBufferSize()
Static function return the default buffer size for automatic histograms the parameter fgBufferSize ma...
Definition TH1.cxx:4406
virtual Double_t DoIntegral(Int_t ix1, Int_t ix2, Int_t iy1, Int_t iy2, Int_t iz1, Int_t iz2, Double_t &err, Option_t *opt, Bool_t doerr=kFALSE) const
Internal function compute integral and optionally the error between the limits specified by the bin n...
Definition TH1.cxx:7945
Double_t fTsumwx2
Total Sum of weight*X*X.
Definition TH1.h:99
virtual Double_t GetStdDev(Int_t axis=1) const
Returns the Standard Deviation (Sigma).
Definition TH1.cxx:7575
TH1()
Histogram default constructor.
Definition TH1.cxx:615
static TH1 * TransformHisto(TVirtualFFT *fft, TH1 *h_output, Option_t *option)
For a given transform (first parameter), fills the histogram (second parameter) with the transform ou...
Definition TH1.cxx:9287
void UseCurrentStyle() override
Copy current attributes from/to current style.
Definition TH1.cxx:7437
virtual void LabelsOption(Option_t *option="h", Option_t *axis="X")
Sort bins with labels or set option(s) to draw axis with labels.
Definition TH1.cxx:5350
virtual Int_t GetNbinsY() const
Definition TH1.h:298
Short_t fBarOffset
(1000*offset) for bar charts or legos
Definition TH1.h:93
virtual Double_t Chi2TestX(const TH1 *h2, Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option="UU", Double_t *res=nullptr) const
The computation routine of the Chisquare test.
Definition TH1.cxx:2067
static bool CheckBinLimits(const TAxis *a1, const TAxis *a2)
Check bin limits.
Definition TH1.cxx:1541
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition TH1.cxx:1268
virtual Double_t GetBinError(Int_t bin) const
Return value of error associated to bin number bin.
Definition TH1.cxx:9031
static Int_t FitOptionsMake(Option_t *option, Foption_t &Foption)
Decode string choptin and fill fitOption structure.
Definition TH1.cxx:4620
virtual Int_t GetNbinsZ() const
Definition TH1.h:299
virtual Double_t GetNormFactor() const
Definition TH1.h:301
virtual Double_t GetMean(Int_t axis=1) const
For axis = 1,2 or 3 returns the mean value of the histogram along X,Y or Z axis.
Definition TH1.cxx:7503
virtual Double_t GetSkewness(Int_t axis=1) const
Definition TH1.cxx:7639
virtual void ClearUnderflowAndOverflow()
Remove all the content from the underflow and overflow bins, without changing the number of entries A...
Definition TH1.cxx:2517
virtual Double_t GetContourLevelPad(Int_t level) const
Return the value of contour number "level" in Pad coordinates.
Definition TH1.cxx:8408
virtual TH1 * DrawNormalized(Option_t *option="", Double_t norm=1) const
Draw a normalized copy of this histogram.
Definition TH1.cxx:3144
@ kNeutral
Adapt to the global flag.
Definition TH1.h:83
virtual Int_t GetDimension() const
Definition TH1.h:283
void Streamer(TBuffer &) override
Stream a class object.
Definition TH1.cxx:6901
static void AddDirectory(Bool_t add=kTRUE)
Sets the flag controlling the automatic add of histograms in memory.
Definition TH1.cxx:1294
@ kIsAverage
Bin contents are average (used by Add)
Definition TH1.h:171
@ kUserContour
User specified contour levels.
Definition TH1.h:166
@ kNoStats
Don't draw stats box.
Definition TH1.h:165
@ kAutoBinPTwo
different than 1.
Definition TH1.h:174
@ kIsNotW
Histogram is forced to be not weighted even when the histogram is filled with weighted.
Definition TH1.h:172
@ kIsHighlight
bit set if histo is highlight
Definition TH1.h:175
virtual void SetContourLevel(Int_t level, Double_t value)
Set value for one contour level.
Definition TH1.cxx:8490
virtual Bool_t CanExtendAllAxes() const
Returns true if all axes are extendable.
Definition TH1.cxx:6604
TDirectory * fDirectory
! Pointer to directory holding this histogram
Definition TH1.h:109
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition TH1.cxx:7071
void SetNameTitle(const char *name, const char *title) override
Change the name and title of this histogram.
Definition TH1.cxx:8942
TAxis * GetXaxis()
Definition TH1.h:324
virtual void GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const
Return binx, biny, binz corresponding to the global bin number globalbin see TH1::GetBin function abo...
Definition TH1.cxx:4942
TH1 * GetCumulative(Bool_t forward=kTRUE, const char *suffix="_cumulative") const
Return a pointer to a histogram containing the cumulative content.
Definition TH1.cxx:2616
static Double_t AutoP2GetPower2(Double_t x, Bool_t next=kTRUE)
Auxiliary function to get the power of 2 next (larger) or previous (smaller) a given x.
Definition TH1.cxx:1308
virtual Int_t GetNcells() const
Definition TH1.h:300
virtual Int_t ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05)
Interface to TSpectrum::Search.
Definition TH1.cxx:9269
static Bool_t RecomputeAxisLimits(TAxis &destAxis, const TAxis &anAxis)
Finds new limits for the axis for the Merge function.
Definition TH1.cxx:5876
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
Definition TH1.cxx:7852
TVirtualHistPainter * GetPainter(Option_t *option="")
Return pointer to painter.
Definition TH1.cxx:4488
TObject * FindObject(const char *name) const override
Search object named name in the list of functions.
Definition TH1.cxx:3857
virtual void FillRandom(const char *fname, Int_t ntimes=5000, TRandom *rng=nullptr)
Fill histogram following distribution in function fname.
Definition TH1.cxx:3519
void Print(Option_t *option="") const override
Print some global quantities for this histogram.
Definition TH1.cxx:6977
static Bool_t GetDefaultSumw2()
Return kTRUE if TH1::Sumw2 must be called when creating new histograms.
Definition TH1.cxx:4415
virtual Int_t FindFirstBinAbove(Double_t threshold=0, Int_t axis=1, Int_t firstBin=1, Int_t lastBin=-1) const
Find first bin with content > threshold for axis (1=x, 2=y, 3=z) if no bins with content > threshold ...
Definition TH1.cxx:3734
virtual TFitResultPtr Fit(const char *formula, Option_t *option="", Option_t *goption="", Double_t xmin=0, Double_t xmax=0)
Fit histogram with function fname.
Definition TH1.cxx:3898
virtual Int_t GetBin(Int_t binx, Int_t biny=0, Int_t binz=0) const
Return Global bin number corresponding to binx,y,z.
Definition TH1.cxx:4929
virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const
Return maximum value smaller than maxval of bins in the range, unless the value has been overridden b...
Definition TH1.cxx:8513
virtual Int_t GetNbinsX() const
Definition TH1.h:297
virtual void SetMaximum(Double_t maximum=-1111)
Definition TH1.h:403
virtual TH1 * FFT(TH1 *h_output, Option_t *option)
This function allows to do discrete Fourier transforms of TH1 and TH2.
Definition TH1.cxx:3284
virtual void LabelsInflate(Option_t *axis="X")
Double the number of bins for axis.
Definition TH1.cxx:5283
virtual TH1 * ShowBackground(Int_t niter=20, Option_t *option="same")
This function calculates the background spectrum in this histogram.
Definition TH1.cxx:9255
static Bool_t SameLimitsAndNBins(const TAxis &axis1, const TAxis &axis2)
Same limits and bins.
Definition TH1.cxx:5866
virtual Bool_t Add(TF1 *h1, Double_t c1=1, Option_t *option="")
Performs the operation: this = this + c1*f1 if errors are defined (see TH1::Sumw2),...
Definition TH1.cxx:826
Double_t fMaximum
Maximum value for plotting.
Definition TH1.h:100
Int_t fBufferSize
fBuffer size
Definition TH1.h:107
virtual Double_t RetrieveBinContent(Int_t bin) const
Raw retrieval of bin content on internal data structure see convention for numbering bins in TH1::Get...
Definition TH1.cxx:9407
virtual Double_t IntegralAndError(Int_t binx1, Int_t binx2, Double_t &err, Option_t *option="") const
Return integral of bin contents in range [binx1,binx2] and its error.
Definition TH1.cxx:7936
Int_t fDimension
! Histogram dimension (1, 2 or 3 dim)
Definition TH1.h:110
virtual void SetBinError(Int_t bin, Double_t error)
Set the bin Error Note that this resets the bin eror option to be of Normal Type and for the non-empt...
Definition TH1.cxx:9174
EBinErrorOpt fBinStatErrOpt
Option for bin statistical errors.
Definition TH1.h:113
static Int_t fgBufferSize
! Default buffer size for automatic histograms
Definition TH1.h:115
virtual void SetBinsLength(Int_t=-1)
Definition TH1.h:380
Double_t fNormFactor
Normalization factor.
Definition TH1.h:102
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition TH1.cxx:3344
TAxis * GetYaxis()
Definition TH1.h:325
TArrayD fContour
Array to display contour levels.
Definition TH1.h:103
virtual Double_t GetBinErrorLow(Int_t bin) const
Return lower error associated to bin number bin.
Definition TH1.cxx:9047
void Browse(TBrowser *b) override
Browse the Histogram object.
Definition TH1.cxx:762
virtual void SetContent(const Double_t *content)
Replace bin contents by the contents of array content.
Definition TH1.cxx:8366
void Draw(Option_t *option="") override
Draw this histogram with options.
Definition TH1.cxx:3066
virtual void SavePrimitiveHelp(std::ostream &out, const char *hname, Option_t *option="")
Helper function for the SavePrimitive functions from TH1 or classes derived from TH1,...
Definition TH1.cxx:7347
Short_t fBarWidth
(1000*width) for bar charts or legos
Definition TH1.h:94
virtual Double_t GetBinErrorSqUnchecked(Int_t bin) const
Definition TH1.h:448
Int_t AxisChoice(Option_t *axis) const
Choose an axis according to "axis".
Definition Haxis.cxx:14
virtual void SetMinimum(Double_t minimum=-1111)
Definition TH1.h:404
Bool_t IsBinUnderflow(Int_t bin, Int_t axis=0) const
Return true if the bin is underflow.
Definition TH1.cxx:5182
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitive as a C++ statement(s) on output stream out.
Definition TH1.cxx:7205
static bool CheckBinLabels(const TAxis *a1, const TAxis *a2)
Check that axis have same labels.
Definition TH1.cxx:1568
virtual Double_t Interpolate(Double_t x) const
Given a point x, approximates the value via linear interpolation based on the two nearest bin centers...
Definition TH1.cxx:5083
static void SetDefaultSumw2(Bool_t sumw2=kTRUE)
When this static function is called with sumw2=kTRUE, all new histograms will automatically activate ...
Definition TH1.cxx:6671
Bool_t IsBinOverflow(Int_t bin, Int_t axis=0) const
Return true if the bin is overflow.
Definition TH1.cxx:5150
UInt_t GetAxisLabelStatus() const
Internal function used in TH1::Fill to see which axis is full alphanumeric, i.e.
Definition TH1.cxx:6643
Double_t * fIntegral
! Integral of bins used by GetRandom
Definition TH1.h:111
Double_t fMinimum
Minimum value for plotting.
Definition TH1.h:101
virtual Double_t Integral(Option_t *option="") const
Return integral of bin contents.
Definition TH1.cxx:7909
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition TH1.cxx:9190
virtual void DirectoryAutoAdd(TDirectory *)
Perform the automatic addition of the histogram to the given directory.
Definition TH1.cxx:2801
virtual void GetLowEdge(Double_t *edge) const
Fill array with low edge of bins for 1D histogram Better to use h1.GetXaxis()->GetLowEdge(edge)
Definition TH1.cxx:9155
virtual Double_t GetBinLowEdge(Int_t bin) const
Return bin lower edge for 1D histogram.
Definition TH1.cxx:9120
void Build()
Creates histogram basic data structure.
Definition TH1.cxx:771
virtual Double_t GetEntries() const
Return the current number of entries.
Definition TH1.cxx:4423
virtual TF1 * GetFunction(const char *name) const
Return pointer to function with name.
Definition TH1.cxx:9019
virtual TH1 * Rebin(Int_t ngroup=2, const char *newname="", const Double_t *xbins=nullptr)
Rebin this histogram.
Definition TH1.cxx:6243
virtual Int_t BufferFill(Double_t x, Double_t w)
accumulate arguments in buffer.
Definition TH1.cxx:1506
virtual Double_t GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx=0, Int_t lastx=0, Double_t maxdiff=0) const
Compute first binx in the range [firstx,lastx] for which diff = abs(bin_content-c) <= maxdiff.
Definition TH1.cxx:5054
virtual UInt_t SetCanExtend(UInt_t extendBitMask)
Make the histogram axes extendable / not extendable according to the bit mask returns the previous bi...
Definition TH1.cxx:6617
TList * GetListOfFunctions() const
Definition TH1.h:244
void SetName(const char *name) override
Change the name of this histogram.
Definition TH1.cxx:8928
virtual TH1 * DrawCopy(Option_t *option="", const char *name_postfix="_copy") const
Copy this histogram and Draw in the current pad.
Definition TH1.cxx:3113
Bool_t IsEmpty() const
Check if a histogram is empty (this is a protected method used mainly by TH1Merger )
Definition TH1.cxx:5132
virtual Double_t GetMeanError(Int_t axis=1) const
Return standard error of mean of this histogram along the X axis.
Definition TH1.cxx:7543
void Paint(Option_t *option="") override
Control routine to paint any kind of histograms.
Definition TH1.cxx:6174
virtual Double_t AndersonDarlingTest(const TH1 *h2, Option_t *option="") const
Statistical test of compatibility in shape between this histogram and h2, using the Anderson-Darling ...
Definition TH1.cxx:8030
virtual void ResetStats()
Reset the statistics including the number of entries and replace with values calculated from bin cont...
Definition TH1.cxx:7870
static void SetDefaultBufferSize(Int_t buffersize=1000)
Static function to set the default buffer size for automatic histograms.
Definition TH1.cxx:6661
virtual void SetBinErrorOption(EBinErrorOpt type)
Definition TH1.h:381
virtual void SetBuffer(Int_t buffersize, Option_t *option="")
Set the maximum number of entries to be kept in the buffer.
Definition TH1.cxx:8426
virtual void DrawPanel()
Display a panel with all histogram drawing options.
Definition TH1.cxx:3175
virtual Double_t GetRandom(TRandom *rng=nullptr) const
Return a random number distributed according the histogram bin contents.
Definition TH1.cxx:4978
virtual Double_t Chisquare(TF1 *f1, Option_t *option="") const
Compute and return the chisquare of this histogram with respect to a function The chisquare is comput...
Definition TH1.cxx:2496
virtual Double_t Chi2Test(const TH1 *h2, Option_t *option="UU", Double_t *res=nullptr) const
test for comparing weighted and unweighted histograms.
Definition TH1.cxx:2008
virtual void DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride=1)
Internal method to fill histogram content from a vector called directly by TH1::BufferEmpty.
Definition TH1.cxx:3473
virtual void GetMinimumAndMaximum(Double_t &min, Double_t &max) const
Retrieve the minimum and maximum values in the histogram.
Definition TH1.cxx:8699
@ kNstat
Size of statistics data (up to TProfile3D)
Definition TH1.h:184
virtual Int_t GetMaximumBin() const
Return location of bin with maximum value in the range.
Definition TH1.cxx:8545
static Int_t AutoP2GetBins(Int_t n)
Auxiliary function to get the next power of 2 integer value larger then n.
Definition TH1.cxx:1321
Double_t fEntries
Number of entries.
Definition TH1.h:95
virtual Long64_t Merge(TCollection *list)
Definition TH1.h:345
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition TH1.cxx:3240
virtual Double_t * GetIntegral()
Return a pointer to the array of bins integral.
Definition TH1.cxx:2586
TAxis fZaxis
Z axis descriptor.
Definition TH1.h:92
EStatOverflows fStatOverflows
Per object flag to use under/overflows in statistics.
Definition TH1.h:114
TClass * IsA() const override
Definition TH1.h:443
virtual void FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride=1)
Fill this histogram with an array x and weights w.
Definition TH1.cxx:3447
virtual void UpdateBinContent(Int_t bin, Double_t content)
Raw update of bin content on internal data structure see convention for numbering bins in TH1::GetBin...
Definition TH1.cxx:9417
static bool CheckEqualAxes(const TAxis *a1, const TAxis *a2)
Check that the axis are the same.
Definition TH1.cxx:1611
@ kPoisson2
Errors from Poisson interval at 95% CL (~ 2 sigma)
Definition TH1.h:67
@ kNormal
Errors with Normal (Wald) approximation: errorUp=errorLow= sqrt(N)
Definition TH1.h:65
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition TH1.cxx:5029
virtual Int_t GetContour(Double_t *levels=nullptr)
Return contour values into array levels if pointer levels is non zero.
Definition TH1.cxx:8379
TAxis fXaxis
X axis descriptor.
Definition TH1.h:90
virtual Bool_t IsHighlight() const
Definition TH1.h:338
virtual void ExtendAxis(Double_t x, TAxis *axis)
Histogram is resized along axis such that x is in the axis range.
Definition TH1.cxx:6472
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width for 1D histogram.
Definition TH1.cxx:9131
TArrayD fSumw2
Array of sum of squares of weights.
Definition TH1.h:104
TH1 * GetAsymmetry(TH1 *h2, Double_t c2=1, Double_t dc2=0)
Return a histogram containing the asymmetry of this histogram with h2, where the asymmetry is defined...
Definition TH1.cxx:4339
virtual Double_t GetContourLevel(Int_t level) const
Return value of contour number level.
Definition TH1.cxx:8398
virtual void SetContour(Int_t nlevels, const Double_t *levels=nullptr)
Set the number and values of contour levels.
Definition TH1.cxx:8451
virtual void SetHighlight(Bool_t set=kTRUE)
Set highlight (enable/disable) mode for the histogram by default highlight mode is disable.
Definition TH1.cxx:4459
virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum=nullptr)
Compute Quantiles for this histogram Quantile x_q of a probability distribution Function F is defined...
Definition TH1.cxx:4579
virtual Double_t GetBinErrorUp(Int_t bin) const
Return upper error associated to bin number bin.
Definition TH1.cxx:9078
virtual void Scale(Double_t c1=1, Option_t *option="")
Multiply this histogram by a constant c1.
Definition TH1.cxx:6572
virtual Int_t GetMinimumBin() const
Return location of bin with minimum value in the range.
Definition TH1.cxx:8633
virtual Int_t GetSumw2N() const
Definition TH1.h:315
virtual Int_t FindBin(Double_t x, Double_t y=0, Double_t z=0)
Return Global bin number corresponding to x,y,z.
Definition TH1.cxx:3672
Bool_t GetStatOverflowsBehaviour() const
Definition TH1.h:152
void SaveAs(const char *filename="hist", Option_t *option="") const override
Save the histogram as .csv, .tsv or .txt.
Definition TH1.cxx:7149
TObject * Clone(const char *newname="") const override
Make a complete copy of the underlying object.
Definition TH1.cxx:2752
virtual Double_t GetStdDevError(Int_t axis=1) const
Return error of standard deviation estimation for Normal distribution.
Definition TH1.cxx:7623
virtual Bool_t Divide(TF1 *f1, Double_t c1=1)
Performs the operation: this = this/(c1*f1) if errors are defined (see TH1::Sumw2),...
Definition TH1.cxx:2840
virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const
Return minimum value larger than minval of bins in the range, unless the value has been overridden by...
Definition TH1.cxx:8603
int LoggedInconsistency(const char *name, const TH1 *h1, const TH1 *h2, bool useMerge=false) const
Definition TH1.cxx:883
static bool CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis *a2, Int_t firstBin2=0, Int_t lastBin2=0)
Check that two sub axis are the same.
Definition TH1.cxx:1640
void RecursiveRemove(TObject *obj) override
Recursively remove object from the list of functions.
Definition TH1.cxx:6544
TAxis fYaxis
Y axis descriptor.
Definition TH1.h:91
virtual Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const
Statistical test of compatibility in shape between this histogram and h2, using Kolmogorov test.
Definition TH1.cxx:8146
virtual Double_t GetSumOfWeights() const
Return the sum of weights excluding under/overflows.
Definition TH1.cxx:7885
static void SmoothArray(Int_t NN, Double_t *XX, Int_t ntimes=1)
Smooth array xx, translation of Hbook routine hsmoof.F.
Definition TH1.cxx:6736
virtual void GetCenter(Double_t *center) const
Fill array with center of bins for 1D histogram Better to use h1.GetXaxis()->GetCenter(center)
Definition TH1.cxx:9142
TVirtualHistPainter * fPainter
! Pointer to histogram painter
Definition TH1.h:112
virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax)
Redefine x axis parameters.
Definition TH1.cxx:8735
virtual Int_t FindFixBin(Double_t x, Double_t y=0, Double_t z=0) const
Return Global bin number corresponding to x,y,z.
Definition TH1.cxx:3705
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition TH1.cxx:8988
virtual void SetEntries(Double_t n)
Definition TH1.h:390
virtual Bool_t FindNewAxisLimits(const TAxis *axis, const Double_t point, Double_t &newMin, Double_t &newMax)
finds new limits for the axis so that point is within the range and the limits are compatible with th...
Definition TH1.cxx:6428
static bool CheckAxisLimits(const TAxis *a1, const TAxis *a2)
Check that the axis limits of the histograms are the same.
Definition TH1.cxx:1597
static Bool_t AddDirectoryStatus()
Static function: cannot be inlined on Windows/NT.
Definition TH1.cxx:754
static Bool_t fgDefaultSumw2
! Flag to call TH1::Sumw2 automatically at histogram creation time
Definition TH1.h:118
Double_t fTsumwx
Total Sum of weight*X.
Definition TH1.h:98
virtual void LabelsDeflate(Option_t *axis="X")
Reduce the number of bins for the axis passed in the option to the number of bins having a label.
Definition TH1.cxx:5213
virtual Double_t ComputeIntegral(Bool_t onlyPositive=false)
Compute integral (normalized cumulative sum of bins) w/o under/overflows The result is stored in fInt...
Definition TH1.cxx:2537
TString fOption
Histogram options.
Definition TH1.h:105
virtual void Eval(TF1 *f1, Option_t *option="")
Evaluate function f1 at the center of bins of this histogram.
Definition TH1.cxx:3192
virtual void SetBarWidth(Float_t width=0.5)
Set the width of bars as fraction of the bin width for drawing mode "B".
Definition TH1.h:365
virtual Int_t BufferEmpty(Int_t action=0)
Fill histogram with all entries in the buffer.
Definition TH1.cxx:1414
virtual void SetStats(Bool_t stats=kTRUE)
Set statistics option on/off.
Definition TH1.cxx:8958
virtual Double_t GetKurtosis(Int_t axis=1) const
Definition TH1.cxx:7712
2-D histogram with a double per channel (see TH1 documentation)
Definition TH2.h:357
static THLimitsFinder * GetLimitsFinder()
Return pointer to the current finder.
virtual Int_t FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax)
Compute the best axis limits for the X axis.
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition THashList.h:34
void Clear(Option_t *option="") override
Remove all objects from the list.
A doubly linked list.
Definition TList.h:38
void Streamer(TBuffer &) override
Stream all objects in the collection to or from the I/O buffer.
Definition TList.cxx:1189
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition TList.cxx:576
void RecursiveRemove(TObject *obj) override
Remove object from this collection and recursively remove the object from all other objects (and coll...
Definition TList.cxx:762
void Add(TObject *obj) override
Definition TList.h:83
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:820
TObject * First() const override
Return the first object in the list. Returns 0 when list is empty.
Definition TList.cxx:657
virtual TObjLink * FirstLink() const
Definition TList.h:104
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:468
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:355
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
void Copy(TObject &named) const override
Copy this to obj.
Definition TNamed.cxx:94
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
void Streamer(TBuffer &) override
Stream an object of class TObject.
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
TString fTitle
Definition TNamed.h:33
TString fName
Definition TNamed.h:32
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140
Mother of all ROOT objects.
Definition TObject.h:41
void AbstractMethod(const char *method) const
Use this method to implement an "abstract" method that you don't want to leave purely abstract.
Definition TObject.cxx:1029
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:199
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition TObject.cxx:457
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
virtual void UseCurrentStyle()
Set current style settings in this object This function is called when either TCanvas::UseCurrentStyl...
Definition TObject.cxx:801
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:973
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition TObject.cxx:184
virtual void SaveAs(const char *filename="", Option_t *option="") const
Save this object in the file specified by filename.
Definition TObject.cxx:686
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:525
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:987
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition TObject.cxx:791
void ResetBit(UInt_t f)
Definition TObject.h:198
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:62
@ kInvalidObject
if object ctor succeeded but object should not be used
Definition TObject.h:72
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition TObject.h:64
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:961
Longptr_t ExecPlugin(int nargs)
Int_t LoadPlugin()
Load the plugin library for this handler.
static TClass * Class()
This is the base class for the ROOT Random number generators.
Definition TRandom.h:27
Double_t Rndm() override
Machine independent random number generator.
Definition TRandom.cxx:559
virtual Double_t PoissonD(Double_t mean)
Generates a random number according to a Poisson law.
Definition TRandom.cxx:461
virtual ULong64_t Poisson(Double_t mean)
Generates a random integer N according to a Poisson law.
Definition TRandom.cxx:404
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
void ToLower()
Change string to lower-case.
Definition TString.cxx:1182
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition TString.cxx:2244
void Clear()
Clear string without changing its capacity.
Definition TString.cxx:1235
const char * Data() const
Definition TString.h:376
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:704
void ToUpper()
Change string to upper case.
Definition TString.cxx:1195
Bool_t IsNull() const
Definition TString.h:414
TString & Remove(Ssiz_t pos)
Definition TString.h:685
virtual void Streamer(TBuffer &)
Stream a string object.
Definition TString.cxx:1412
TString & Append(const char *cs)
Definition TString.h:572
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2378
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2356
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:632
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
Int_t GetOptStat() const
Definition TStyle.h:243
void SetOptStat(Int_t stat=1)
The type of information printed in the histogram statistics box can be selected via the parameter mod...
Definition TStyle.cxx:1636
void SetHistFillColor(Color_t color=1)
Definition TStyle.h:376
Color_t GetHistLineColor() const
Definition TStyle.h:231
Bool_t IsReading() const
Definition TStyle.h:294
Float_t GetBarOffset() const
Definition TStyle.h:181
void SetHistLineStyle(Style_t styl=0)
Definition TStyle.h:379
Style_t GetHistFillStyle() const
Definition TStyle.h:232
Color_t GetHistFillColor() const
Definition TStyle.h:230
Float_t GetBarWidth() const
Definition TStyle.h:182
Bool_t GetCanvasPreferGL() const
Definition TStyle.h:186
void SetHistLineColor(Color_t color=1)
Definition TStyle.h:377
void SetBarOffset(Float_t baroff=0.5)
Definition TStyle.h:333
Style_t GetHistLineStyle() const
Definition TStyle.h:233
void SetBarWidth(Float_t barwidth=0.5)
Definition TStyle.h:334
void SetHistFillStyle(Style_t styl=0)
Definition TStyle.h:378
Width_t GetHistLineWidth() const
Definition TStyle.h:234
Int_t GetOptFit() const
Definition TStyle.h:242
void SetHistLineWidth(Width_t width=1)
Definition TStyle.h:380
TVectorT.
Definition TVectorT.h:27
TVirtualFFT is an interface class for Fast Fourier Transforms.
Definition TVirtualFFT.h:88
static TVirtualFFT * FFT(Int_t ndim, Int_t *n, Option_t *option)
Returns a pointer to the FFT of requested size and type.
virtual Int_t GetNdim() const =0
static TVirtualFFT * SineCosine(Int_t ndim, Int_t *n, Int_t *r2rkind, Option_t *option)
Returns a pointer to a sine or cosine transform of requested size and kind.
virtual Option_t * GetType() const =0
virtual void Transform()=0
virtual void GetPointComplex(Int_t ipoint, Double_t &re, Double_t &im, Bool_t fromInput=kFALSE) const =0
virtual Int_t * GetN() const =0
virtual Double_t GetPointReal(Int_t ipoint, Bool_t fromInput=kFALSE) const =0
virtual void SetPoint(Int_t ipoint, Double_t re, Double_t im=0)=0
Abstract Base Class for Fitting.
virtual Int_t GetXlast() const
virtual TObject * GetObjectFit() const
virtual Int_t GetXfirst() const
static TVirtualFitter * GetFitter()
static: return the current Fitter
virtual TObject * GetUserFunc() const
Abstract interface to a histogram painter.
virtual void DrawPanel()=0
Int_t DistancetoPrimitive(Int_t px, Int_t py) override=0
Computes distance from point (px,py) to the object.
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override=0
Execute action corresponding to an event at (px,py).
virtual void SetHighlight()=0
static TVirtualHistPainter * HistPainter(TH1 *obj)
Static function returning a pointer to the current histogram painter.
void Paint(Option_t *option="") override=0
This method must be overridden if a class wants to paint itself.
virtual void SetParent(TObject *)=0
double gamma_quantile_c(double z, double alpha, double theta)
Inverse ( ) of the cumulative distribution function of the upper tail of the gamma distribution (gamm...
double gamma_quantile(double z, double alpha, double theta)
Inverse ( ) of the cumulative distribution function of the lower tail of the gamma distribution (gamm...
const Double_t sigma
Double_t y[n]
Definition legend1.C:17
return c1
Definition legend1.C:41
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
TH1F * h1
Definition legend1.C:5
TF1 * f1
Definition legend1.C:11
return c2
Definition legend2.C:14
R__ALWAYS_INLINE bool HasBeenDeleted(const TObject *obj)
Check if the TObject's memory has been deleted.
Definition TObject.h:402
TFitResultPtr FitObject(TH1 *h1, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption, const char *goption, ROOT::Fit::DataRange &range)
fitting function for a TH1 (called from TH1::Fit)
Definition HFitImpl.cxx:972
double Chisquare(const TH1 &h1, TF1 &f1, bool useRange, EChisquareType type)
compute the chi2 value for an histogram given a function (see TH1::Chisquare for the documentation)
void FitOptionsMake(EFitObjectType type, const char *option, Foption_t &fitOption)
Decode list of options into fitOption.
Definition HFitImpl.cxx:685
void FillData(BinData &dv, const TH1 *hist, TF1 *func=nullptr)
fill the data vector from a TH1.
R__EXTERN TVirtualRWMutex * gCoreMutex
Bool_t IsNaN(Double_t x)
Definition TMath.h:892
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition TMath.h:693
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition TMathBase.h:250
Double_t Prob(Double_t chi2, Int_t ndf)
Computation of the probability for a certain Chi-squared (chi2) and number of degrees of freedom (ndf...
Definition TMath.cxx:637
Double_t Median(Long64_t n, const T *a, const Double_t *w=nullptr, Long64_t *work=nullptr)
Same as RMS.
Definition TMath.h:1272
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
Definition TMath.h:902
Double_t Floor(Double_t x)
Rounds x downward, returning the largest integral value that is not greater than x.
Definition TMath.h:680
Double_t ATan(Double_t)
Returns the principal value of the arc tangent of x, expressed in radians.
Definition TMath.h:640
Double_t Ceil(Double_t x)
Rounds x upward, returning the smallest integral value that is not less than x.
Definition TMath.h:668
T MinElement(Long64_t n, const T *a)
Returns minimum of array a of length n.
Definition TMath.h:960
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Definition TMath.h:756
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition TMath.h:662
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition TMath.h:721
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:198
constexpr Double_t Pi()
Definition TMath.h:37
Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec)
Comparing floating points.
Definition TMath.h:426
Bool_t AreEqualAbs(Double_t af, Double_t bf, Double_t epsilon)
Comparing floating points.
Definition TMath.h:418
Double_t KolmogorovProb(Double_t z)
Calculates the Kolmogorov distribution function,.
Definition TMath.cxx:679
void Sort(Index n, const Element *a, Index *index, Bool_t down=kTRUE)
Sort the n elements of the array a of generic templated type Element.
Definition TMathBase.h:431
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Binary search in an array of n values to locate value.
Definition TMathBase.h:347
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition TMath.h:762
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123
Double_t Infinity()
Returns an infinity as defined by the IEEE standard.
Definition TMath.h:917
th1 Draw()
TMarker m
Definition textangle.C:8
TLine l
Definition textangle.C:4
static uint64_t sum(uint64_t i)
Definition Factory.cxx:2345