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