Logo ROOT   6.08/07
Reference Guide
TH2.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 "TROOT.h"
13 #include "TClass.h"
14 #include "THashList.h"
15 #include "TH2.h"
16 #include "TVirtualPad.h"
17 #include "TF2.h"
18 #include "TProfile.h"
19 #include "TRandom.h"
20 #include "TMatrixFBase.h"
21 #include "TMatrixDBase.h"
22 #include "THLimitsFinder.h"
23 #include "TError.h"
24 #include "TMath.h"
25 #include "TObjString.h"
26 #include "TVirtualHistPainter.h"
27 
28 
30 
31 /** \addtogroup Hist
32 @{
33 \class TH2C
34 \brief tomato 2-D histogram with a byte per channel (see TH1 documentation)
35 \class TH2S
36 \brief tomato 2-D histogram with a short per channel (see TH1 documentation)
37 \class TH2I
38 \brief tomato 2-D histogram with an int per channel (see TH1 documentation)}
39 \class TH2F
40 \brief tomato 2-D histogram with a float per channel (see TH1 documentation)}
41 \class TH2D
42 \brief tomato 2-D histogram with a double per channel (see TH1 documentation)}
43 @}
44 */
45 
46 /** \class TH2
47  Service class for 2-Dim histogram classes
48 
49 - TH2C a 2-D histogram with one byte per cell (char)
50 - TH2S a 2-D histogram with two bytes per cell (short integer)
51 - TH2I a 2-D histogram with four bytes per cell (32 bits integer)
52 - TH2F a 2-D histogram with four bytes per cell (float)
53 - TH2D a 2-D histogram with eight bytes per cell (double)
54 */
55 
56 
57 ////////////////////////////////////////////////////////////////////////////////
58 /// Constructor.
59 
60 TH2::TH2()
61 {
62  fDimension = 2;
63  fScalefactor = 1;
64  fTsumwy = fTsumwy2 = fTsumwxy = 0;
65 }
66 
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// See comments in the TH1 base class constructors.
70 
71 TH2::TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
72  ,Int_t nbinsy,Double_t ylow,Double_t yup)
73  :TH1(name,title,nbinsx,xlow,xup)
74 {
75  fDimension = 2;
76  fScalefactor = 1;
77  fTsumwy = fTsumwy2 = fTsumwxy = 0;
78  if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
79  fYaxis.Set(nbinsy,ylow,yup);
80  fNcells = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
81 }
82 
83 
84 ////////////////////////////////////////////////////////////////////////////////
85 /// See comments in the TH1 base class constructors.
86 
87 TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
88  ,Int_t nbinsy,Double_t ylow,Double_t yup)
89  :TH1(name,title,nbinsx,xbins)
90 {
91  fDimension = 2;
92  fScalefactor = 1;
93  fTsumwy = fTsumwy2 = fTsumwxy = 0;
94  if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
95  fYaxis.Set(nbinsy,ylow,yup);
96  fNcells = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
97 }
98 
99 
100 ////////////////////////////////////////////////////////////////////////////////
101 /// See comments in the TH1 base class constructors.
102 
103 TH2::TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
104  ,Int_t nbinsy,const Double_t *ybins)
105  :TH1(name,title,nbinsx,xlow,xup)
106 {
107  fDimension = 2;
108  fScalefactor = 1;
109  fTsumwy = fTsumwy2 = fTsumwxy = 0;
110  if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
111  if (ybins) fYaxis.Set(nbinsy,ybins);
112  else fYaxis.Set(nbinsy,0,1);
113  fNcells = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
114 }
115 
116 
117 ////////////////////////////////////////////////////////////////////////////////
118 /// See comments in the TH1 base class constructors.
119 
120 TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
121  ,Int_t nbinsy,const Double_t *ybins)
122  :TH1(name,title,nbinsx,xbins)
123 {
124  fDimension = 2;
125  fScalefactor = 1;
126  fTsumwy = fTsumwy2 = fTsumwxy = 0;
127  if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
128  if (ybins) fYaxis.Set(nbinsy,ybins);
129  else fYaxis.Set(nbinsy,0,1);
130  fNcells = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
131 }
132 
133 
134 ////////////////////////////////////////////////////////////////////////////////
135 /// See comments in the TH1 base class constructors.
136 
137 TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
138  ,Int_t nbinsy,const Float_t *ybins)
139  :TH1(name,title,nbinsx,xbins)
140 {
141  fDimension = 2;
142  fScalefactor = 1;
143  fTsumwy = fTsumwy2 = fTsumwxy = 0;
144  if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
145  if (ybins) fYaxis.Set(nbinsy,ybins);
146  else fYaxis.Set(nbinsy,0,1);
147  fNcells = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor.
148 }
149 
150 
151 ////////////////////////////////////////////////////////////////////////////////
152 /// Copy constructor.
153 /// The list of functions is not copied. (Use Clone if needed)
154 
155 TH2::TH2(const TH2 &h) : TH1()
156 {
157  ((TH2&)h).Copy(*this);
158 }
159 
160 
161 ////////////////////////////////////////////////////////////////////////////////
162 /// Destructor.
163 
165 {
166 }
167 
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Fill histogram with all entries in the buffer.
171 /// - action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
172 /// - action = 0 histogram is filled from the buffer
173 /// - action = 1 histogram is filled and buffer is deleted
174 /// The buffer is automatically deleted when the number of entries
175 /// in the buffer is greater than the number of entries in the histogram
176 
178 {
179  // do we need to compute the bin size?
180  if (!fBuffer) return 0;
181  Int_t nbentries = (Int_t)fBuffer[0];
182 
183  // nbentries correspond to the number of entries of histogram
184 
185  if (nbentries == 0) return 0;
186  if (nbentries < 0 && action == 0) return 0; // case histogram has been already filled from the buffer
187 
188  Double_t *buffer = fBuffer;
189  if (nbentries < 0) {
190  nbentries = -nbentries;
191  // a reset might call BufferEmpty() giving an infinite loop
192  // Protect it by setting fBuffer = 0
193  fBuffer=0;
194  //do not reset the list of functions
195  Reset("ICES");
196  fBuffer = buffer;
197  }
198 
200  //find min, max of entries in buffer
201  Double_t xmin = fBuffer[2];
202  Double_t xmax = xmin;
203  Double_t ymin = fBuffer[3];
204  Double_t ymax = ymin;
205  for (Int_t i=1;i<nbentries;i++) {
206  Double_t x = fBuffer[3*i+2];
207  if (x < xmin) xmin = x;
208  if (x > xmax) xmax = x;
209  Double_t y = fBuffer[3*i+3];
210  if (y < ymin) ymin = y;
211  if (y > ymax) ymax = y;
212  }
213  if (fXaxis.GetXmax() <= fXaxis.GetXmin() || fYaxis.GetXmax() <= fYaxis.GetXmin()) {
214  THLimitsFinder::GetLimitsFinder()->FindGoodLimits(this,xmin,xmax,ymin,ymax);
215  } else {
216  fBuffer = 0;
217  Int_t keep = fBufferSize; fBufferSize = 0;
218  if (xmin < fXaxis.GetXmin()) ExtendAxis(xmin,&fXaxis);
219  if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax,&fXaxis);
220  if (ymin < fYaxis.GetXmin()) ExtendAxis(ymin,&fYaxis);
221  if (ymax >= fYaxis.GetXmax()) ExtendAxis(ymax,&fYaxis);
222  fBuffer = buffer;
223  fBufferSize = keep;
224  }
225  }
226 
227  fBuffer = 0;
228  for (Int_t i=0;i<nbentries;i++) {
229  Fill(buffer[3*i+2],buffer[3*i+3],buffer[3*i+1]);
230  }
231  fBuffer = buffer;
232 
233  if (action > 0) { delete [] fBuffer; fBuffer = 0; fBufferSize = 0;}
234  else {
235  if (nbentries == (Int_t)fEntries) fBuffer[0] = -nbentries;
236  else fBuffer[0] = 0;
237  }
238  return nbentries;
239 }
240 
241 
242 ////////////////////////////////////////////////////////////////////////////////
243 /// accumulate arguments in buffer. When buffer is full, empty the buffer
244 /// ~~~ {.cpp}
245 /// fBuffer[0] = number of entries in buffer
246 /// fBuffer[1] = w of first entry
247 /// fBuffer[2] = x of first entry
248 /// fBuffer[3] = y of first entry
249 /// ~~~
250 
252 {
253  if (!fBuffer) return -3;
254  Int_t nbentries = (Int_t)fBuffer[0];
255  if (nbentries < 0) {
256  nbentries = -nbentries;
257  fBuffer[0] = nbentries;
258  if (fEntries > 0) {
259  Double_t *buffer = fBuffer; fBuffer=0;
260  Reset("ICES");
261  fBuffer = buffer;
262  }
263  }
264  if (3*nbentries+3 >= fBufferSize) {
265  BufferEmpty(1);
266  return Fill(x,y,w);
267  }
268  fBuffer[3*nbentries+1] = w;
269  fBuffer[3*nbentries+2] = x;
270  fBuffer[3*nbentries+3] = y;
271  fBuffer[0] += 1;
272  return -3;
273 }
274 
275 
276 ////////////////////////////////////////////////////////////////////////////////
277 /// Copy.
278 
279 void TH2::Copy(TObject &obj) const
280 {
281  TH1::Copy(obj);
282  ((TH2&)obj).fScalefactor = fScalefactor;
283  ((TH2&)obj).fTsumwy = fTsumwy;
284  ((TH2&)obj).fTsumwy2 = fTsumwy2;
285  ((TH2&)obj).fTsumwxy = fTsumwxy;
286 }
287 
288 
289 ////////////////////////////////////////////////////////////////////////////////
290 /// Invalid Fill method.
291 
293 {
294  Error("Fill", "Invalid signature - do nothing");
295  return -1;
296 }
297 
298 
299 ////////////////////////////////////////////////////////////////////////////////
300 /// Increment cell defined by x,y by 1.
301 ///
302 /// - if x or/and y is less than the low-edge of the corresponding axis first bin,
303 /// the Underflow cell is incremented.
304 /// - if x or/and y is greater than the upper edge of corresponding axis last bin,
305 /// the Overflow cell is incremented.
306 ///
307 /// - If the storage of the sum of squares of weights has been triggered,
308 /// via the function Sumw2, then the sum of the squares of weights is incremented
309 /// by 1 in the cell corresponding to x,y.
310 ///
311 /// The function returns the corresponding global bin number which has its content
312 /// incremented by 1
313 
315 {
316  if (fBuffer) return BufferFill(x,y,1);
317 
318  Int_t binx, biny, bin;
319  fEntries++;
320  binx = fXaxis.FindBin(x);
321  biny = fYaxis.FindBin(y);
322  if (binx <0 || biny <0) return -1;
323  bin = biny*(fXaxis.GetNbins()+2) + binx;
324  AddBinContent(bin);
325  if (fSumw2.fN) ++fSumw2.fArray[bin];
326  if (binx == 0 || binx > fXaxis.GetNbins()) {
327  if (!fgStatOverflows) return -1;
328  }
329  if (biny == 0 || biny > fYaxis.GetNbins()) {
330  if (!fgStatOverflows) return -1;
331  }
332  ++fTsumw;
333  ++fTsumw2;
334  fTsumwx += x;
335  fTsumwx2 += x*x;
336  fTsumwy += y;
337  fTsumwy2 += y*y;
338  fTsumwxy += x*y;
339  return bin;
340 }
341 
342 
343 ////////////////////////////////////////////////////////////////////////////////
344 /// Increment cell defined by x,y by a weight w.
345 ///
346 /// - if x or/and y is less than the low-edge of the corresponding axis first bin,
347 /// the Underflow cell is incremented.
348 /// - if x or/and y is greater than the upper edge of corresponding axis last bin,
349 /// the Overflow cell is incremented.
350 ///
351 /// - If the weight is not equal to 1, the storage of the sum of squares of
352 /// weights is automatically triggered and the sum of the squares of weights is incremented
353 /// by w^2 in the bin corresponding to x,y
354 ///
355 /// The function returns the corresponding global bin number which has its content
356 /// incremented by w
357 
359 {
360  if (fBuffer) return BufferFill(x,y,w);
361 
362  Int_t binx, biny, bin;
363  fEntries++;
364  binx = fXaxis.FindBin(x);
365  biny = fYaxis.FindBin(y);
366  if (binx <0 || biny <0) return -1;
367  bin = biny*(fXaxis.GetNbins()+2) + binx;
368  if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2(); // must be called before AddBinContent
369  if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
370  AddBinContent(bin,w);
371  if (binx == 0 || binx > fXaxis.GetNbins()) {
372  if (!fgStatOverflows) return -1;
373  }
374  if (biny == 0 || biny > fYaxis.GetNbins()) {
375  if (!fgStatOverflows) return -1;
376  }
377  Double_t z= w;
378  fTsumw += z;
379  fTsumw2 += z*z;
380  fTsumwx += z*x;
381  fTsumwx2 += z*x*x;
382  fTsumwy += z*y;
383  fTsumwy2 += z*y*y;
384  fTsumwxy += z*x*y;
385  return bin;
386 }
387 
388 
389 ////////////////////////////////////////////////////////////////////////////////
390 /// Increment cell defined by namex,namey by a weight w
391 ///
392 /// - if x or/and y is less than the low-edge of the corresponding axis first bin,
393 /// the Underflow cell is incremented.
394 /// - if x or/and y is greater than the upper edge of corresponding axis last bin,
395 /// the Overflow cell is incremented.
396 ///
397 /// - If the weight is not equal to 1, the storage of the sum of squares of
398 /// weights is automatically triggered and the sum of the squares of weights is incremented
399 /// by w^2 in the bin corresponding to namex,namey
400 ///
401 /// The function returns the corresponding global bin number which has its content
402 /// incremented by w
403 
404 Int_t TH2::Fill(const char *namex, const char *namey, Double_t w)
405 {
406  Int_t binx, biny, bin;
407  fEntries++;
408  binx = fXaxis.FindBin(namex);
409  biny = fYaxis.FindBin(namey);
410  if (binx <0 || biny <0) return -1;
411  bin = biny*(fXaxis.GetNbins()+2) + binx;
412  if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2(); // must be called before AddBinContent
413  if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
414  AddBinContent(bin,w);
415  if (binx == 0 || binx > fXaxis.GetNbins()) return -1;
416  if (biny == 0 || biny > fYaxis.GetNbins()) return -1;
417  Double_t x = fXaxis.GetBinCenter(binx);
418  Double_t y = fYaxis.GetBinCenter(biny);
419  Double_t z= w;
420  fTsumw += z;
421  fTsumw2 += z*z;
422  fTsumwx += z*x;
423  fTsumwx2 += z*x*x;
424  fTsumwy += z*y;
425  fTsumwy2 += z*y*y;
426  fTsumwxy += z*x*y;
427  return bin;
428 }
429 
430 
431 ////////////////////////////////////////////////////////////////////////////////
432 /// Increment cell defined by namex,y by a weight w
433 ///
434 /// - if x or/and y is less than the low-edge of the corresponding axis first bin,
435 /// the Underflow cell is incremented.
436 /// - if x or/and y is greater than the upper edge of corresponding axis last bin,
437 /// the Overflow cell is incremented.
438 ///
439 /// - If the weight is not equal to 1, the storage of the sum of squares of
440 /// weights is automatically triggered and the sum of the squares of weights is incremented
441 /// by w^2 in the bin corresponding to namex,y
442 ///
443 /// The function returns the corresponding global bin number which has its content
444 /// incremented by w
445 
446 Int_t TH2::Fill(const char *namex, Double_t y, Double_t w)
447 {
448  Int_t binx, biny, bin;
449  fEntries++;
450  binx = fXaxis.FindBin(namex);
451  biny = fYaxis.FindBin(y);
452  if (binx <0 || biny <0) return -1;
453  bin = biny*(fXaxis.GetNbins()+2) + binx;
454  if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2(); // must be called before AddBinContent
455  if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
456  AddBinContent(bin,w);
457  if (binx == 0 || binx > fXaxis.GetNbins()) return -1;
458  if (biny == 0 || biny > fYaxis.GetNbins()) {
459  if (!fgStatOverflows) return -1;
460  }
461  Double_t x = fXaxis.GetBinCenter(binx);
462  Double_t z= w; //(w > 0 ? w : -w);
463  fTsumw += z;
464  fTsumw2 += z*z;
465  fTsumwx += z*x;
466  fTsumwx2 += z*x*x;
467  fTsumwy += z*y;
468  fTsumwy2 += z*y*y;
469  fTsumwxy += z*x*y;
470  return bin;
471 }
472 
473 
474 ////////////////////////////////////////////////////////////////////////////////
475 /// Increment cell defined by x,namey by a weight w
476 ///
477 /// - if x or/and y is less than the low-edge of the corresponding axis first bin,
478 /// the Underflow cell is incremented.
479 /// - if x or/and y is greater than the upper edge of corresponding axis last bin,
480 /// the Overflow cell is incremented.
481 ///
482 /// - If the weight is not equal to 1, the storage of the sum of squares of
483 /// weights is automatically triggered and the sum of the squares of weights is incremented
484 /// by w^2 in the bin corresponding to x,y.
485 ///
486 /// The function returns the corresponding global bin number which has its content
487 /// incremented by w
488 
489 Int_t TH2::Fill(Double_t x, const char *namey, Double_t w)
490 {
491  Int_t binx, biny, bin;
492  fEntries++;
493  binx = fXaxis.FindBin(x);
494  biny = fYaxis.FindBin(namey);
495  if (binx <0 || biny <0) return -1;
496  bin = biny*(fXaxis.GetNbins()+2) + binx;
497  if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2(); // must be called before AddBinContent
498  if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
499  AddBinContent(bin,w);
500  if (binx == 0 || binx > fXaxis.GetNbins()) {
501  if (!fgStatOverflows) return -1;
502  }
503  if (biny == 0 || biny > fYaxis.GetNbins()) return -1;
504  Double_t y = fYaxis.GetBinCenter(biny);
505  Double_t z= w; //(w > 0 ? w : -w);
506  fTsumw += z;
507  fTsumw2 += z*z;
508  fTsumwx += z*x;
509  fTsumwx2 += z*x*x;
510  fTsumwy += z*y;
511  fTsumwy2 += z*y*y;
512  fTsumwxy += z*x*y;
513  return bin;
514 }
515 
516 
517 ////////////////////////////////////////////////////////////////////////////////
518 /// Fill a 2-D histogram with an array of values and weights.
519 ///
520 /// - ntimes: number of entries in arrays x and w (array size must be ntimes*stride)
521 /// - x: array of x values to be histogrammed
522 /// - y: array of y values to be histogrammed
523 /// - w: array of weights
524 /// - stride: step size through arrays x, y and w
525 ///
526 /// - If the weight is not equal to 1, the storage of the sum of squares of
527 /// weights is automatically triggered and the sum of the squares of weights is incremented
528 /// by w[i]^2 in the bin corresponding to x[i],y[i].
529 /// - If w is NULL each entry is assumed a weight=1
530 ///
531 /// NB: function only valid for a TH2x object
532 
533 void TH2::FillN(Int_t ntimes, const Double_t *x, const Double_t *y, const Double_t *w, Int_t stride)
534 {
535  Int_t binx, biny, bin, i;
536  ntimes *= stride;
537  Int_t ifirst = 0;
538 
539  //If a buffer is activated, fill buffer
540  // (note that this function must not be called from TH2::BufferEmpty)
541  if (fBuffer) {
542  for (i=0;i<ntimes;i+=stride) {
543  if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty
544  if (w) BufferFill(x[i],y[i],w[i]);
545  else BufferFill(x[i], y[i], 1.);
546  }
547  // fill the remaining entries if the buffer has been deleted
548  if (i < ntimes && fBuffer==0)
549  ifirst = i;
550  else
551  return;
552  }
553 
554  Double_t ww = 1;
555  for (i=ifirst;i<ntimes;i+=stride) {
556  fEntries++;
557  binx = fXaxis.FindBin(x[i]);
558  biny = fYaxis.FindBin(y[i]);
559  if (binx <0 || biny <0) continue;
560  bin = biny*(fXaxis.GetNbins()+2) + binx;
561  if (w) ww = w[i];
562  if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2();
563  if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
564  AddBinContent(bin,ww);
565  if (binx == 0 || binx > fXaxis.GetNbins()) {
566  if (!fgStatOverflows) continue;
567  }
568  if (biny == 0 || biny > fYaxis.GetNbins()) {
569  if (!fgStatOverflows) continue;
570  }
571  Double_t z= ww; //(ww > 0 ? ww : -ww);
572  fTsumw += z;
573  fTsumw2 += z*z;
574  fTsumwx += z*x[i];
575  fTsumwx2 += z*x[i]*x[i];
576  fTsumwy += z*y[i];
577  fTsumwy2 += z*y[i]*y[i];
578  fTsumwxy += z*x[i]*y[i];
579  }
580 }
581 
582 
583 ////////////////////////////////////////////////////////////////////////////////
584 /// Fill histogram following distribution in function fname.
585 ///
586 /// The distribution contained in the function fname (TF2) is integrated
587 /// over the channel contents.
588 /// It is normalized to 1.
589 /// Getting one random number implies:
590 /// - Generating a random number between 0 and 1 (say r1)
591 /// - Look in which bin in the normalized integral r1 corresponds to
592 /// - Fill histogram channel
593 /// ntimes random numbers are generated
594 ///
595 /// One can also call TF2::GetRandom2 to get a random variate from a function.
596 
597 void TH2::FillRandom(const char *fname, Int_t ntimes)
598 {
599  Int_t bin, binx, biny, ibin, loop;
600  Double_t r1, x, y;
601  //*-*- Search for fname in the list of ROOT defined functions
602  TObject *fobj = gROOT->GetFunction(fname);
603  if (!fobj) { Error("FillRandom", "Unknown function: %s",fname); return; }
604  TF2 * f1 = dynamic_cast<TF2*>(fobj);
605  if (!f1) { Error("FillRandom", "Function: %s is not a TF2",fname); return; }
606 
607  // Allocate temporary space to store the integral and compute integral
608  Int_t nbinsx = GetNbinsX();
609  Int_t nbinsy = GetNbinsY();
610  Int_t nbins = nbinsx*nbinsy;
611 
612  Double_t *integral = new Double_t[nbins+1];
613  ibin = 0;
614  integral[ibin] = 0;
615  for (biny=1;biny<=nbinsy;biny++) {
616  for (binx=1;binx<=nbinsx;binx++) {
617  ibin++;
619  integral[ibin] = integral[ibin-1] + fint;
620  }
621  }
622 
623  // Normalize integral to 1
624  if (integral[nbins] == 0 ) {
625  delete [] integral;
626  Error("FillRandom", "Integral = zero"); return;
627  }
628  for (bin=1;bin<=nbins;bin++) integral[bin] /= integral[nbins];
629 
630  // Start main loop ntimes
631  for (loop=0;loop<ntimes;loop++) {
632  r1 = gRandom->Rndm();
633  ibin = TMath::BinarySearch(nbins,&integral[0],r1);
634  biny = ibin/nbinsx;
635  binx = 1 + ibin - nbinsx*biny;
636  biny++;
637  x = fXaxis.GetBinCenter(binx);
638  y = fYaxis.GetBinCenter(biny);
639  Fill(x,y);
640  }
641  delete [] integral;
642 }
643 
644 
645 ////////////////////////////////////////////////////////////////////////////////
646 /// Fill histogram following distribution in histogram h.
647 ///
648 /// The distribution contained in the histogram h (TH2) is integrated
649 /// over the channel contents.
650 /// It is normalized to 1.
651 /// Getting one random number implies:
652 /// - Generating a random number between 0 and 1 (say r1)
653 /// - Look in which bin in the normalized integral r1 corresponds to
654 /// - Fill histogram channel
655 /// ntimes random numbers are generated
656 
657 void TH2::FillRandom(TH1 *h, Int_t ntimes)
658 {
659  if (!h) { Error("FillRandom", "Null histogram"); return; }
660  if (fDimension != h->GetDimension()) {
661  Error("FillRandom", "Histograms with different dimensions"); return;
662  }
663 
664  if (h->ComputeIntegral() == 0) return;
665 
666  Int_t loop;
667  Double_t x,y;
668  TH2 *h2 = (TH2*)h;
669  for (loop=0;loop<ntimes;loop++) {
670  h2->GetRandom2(x,y);
671  Fill(x,y);
672  }
673 }
674 
675 
676 ////////////////////////////////////////////////////////////////////////////////
677 /// Find first bin with content > threshold for axis (1=x, 2=y, 3=z)
678 /// if no bins with content > threshold is found the function returns -1.
679 
681 {
682  if (axis < 1 || axis > 2) {
683  Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
684  axis = 1;
685  }
686  Int_t nbinsx = fXaxis.GetNbins();
687  Int_t nbinsy = fYaxis.GetNbins();
688  Int_t binx, biny;
689  if (axis == 1) {
690  for (binx=1;binx<=nbinsx;binx++) {
691  for (biny=1;biny<=nbinsy;biny++) {
692  if (GetBinContent(binx,biny) > threshold) return binx;
693  }
694  }
695  } else {
696  for (biny=1;biny<=nbinsy;biny++) {
697  for (binx=1;binx<=nbinsx;binx++) {
698  if (GetBinContent(binx,biny) > threshold) return biny;
699  }
700  }
701  }
702  return -1;
703 }
704 
705 
706 ////////////////////////////////////////////////////////////////////////////////
707 /// Find last bin with content > threshold for axis (1=x, 2=y, 3=z)
708 /// if no bins with content > threshold is found the function returns -1.
709 
711 {
712  if (axis < 1 || axis > 2) {
713  Warning("FindLastBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
714  axis = 1;
715  }
716  Int_t nbinsx = fXaxis.GetNbins();
717  Int_t nbinsy = fYaxis.GetNbins();
718  Int_t binx, biny;
719  if (axis == 1) {
720  for (binx=nbinsx;binx>=1;binx--) {
721  for (biny=1;biny<=nbinsy;biny++) {
722  if (GetBinContent(binx,biny) > threshold) return binx;
723  }
724  }
725  } else {
726  for (biny=nbinsy;biny>=1;biny--) {
727  for (binx=1;binx<=nbinsx;binx++) {
728  if (GetBinContent(binx,biny) > threshold) return biny;
729  }
730  }
731  }
732  return -1;
733 }
734 
735 
736 ////////////////////////////////////////////////////////////////////////////////
737 
738 void TH2::DoFitSlices(bool onX,
739  TF1 *f1, Int_t firstbin, Int_t lastbin, Int_t cut, Option_t *option, TObjArray* arr)
740 {
741  TAxis& outerAxis = (onX ? fYaxis : fXaxis);
742  TAxis& innerAxis = (onX ? fXaxis : fYaxis);
743 
744  Int_t nbins = outerAxis.GetNbins();
745  if (firstbin < 0) firstbin = 0;
746  if (lastbin < 0 || lastbin > nbins + 1) lastbin = nbins + 1;
747  if (lastbin < firstbin) {firstbin = 0; lastbin = nbins + 1;}
748  TString opt = option;
749  opt.ToLower();
750  Int_t ngroup = 1;
751  if (opt.Contains("g2")) {ngroup = 2; opt.ReplaceAll("g2","");}
752  if (opt.Contains("g3")) {ngroup = 3; opt.ReplaceAll("g3","");}
753  if (opt.Contains("g4")) {ngroup = 4; opt.ReplaceAll("g4","");}
754  if (opt.Contains("g5")) {ngroup = 5; opt.ReplaceAll("g5","");}
755 
756  // implement option S sliding merge for each bin using in conjunction with a given Gn
757  Int_t nstep = ngroup;
758  if (opt.Contains("s")) nstep = 1;
759 
760  //default is to fit with a gaussian
761  if (f1 == 0) {
762  f1 = (TF1*)gROOT->GetFunction("gaus");
763  if (f1 == 0) f1 = new TF1("gaus","gaus",innerAxis.GetXmin(),innerAxis.GetXmax());
764  else f1->SetRange(innerAxis.GetXmin(),innerAxis.GetXmax());
765  }
766  Int_t npar = f1->GetNpar();
767  if (npar <= 0) return;
768  Double_t *parsave = new Double_t[npar];
769  f1->GetParameters(parsave);
770 
771  if (arr) {
772  arr->SetOwner();
773  arr->Expand(npar + 1);
774  }
775 
776  //Create one histogram for each function parameter
777  Int_t ipar;
778  TH1D **hlist = new TH1D*[npar];
779  char *name = new char[2000];
780  char *title = new char[2000];
781  const TArrayD *bins = outerAxis.GetXbins();
782  for (ipar=0;ipar<npar;ipar++) {
783  snprintf(name,2000,"%s_%d",GetName(),ipar);
784  snprintf(title,2000,"Fitted value of par[%d]=%s",ipar,f1->GetParName(ipar));
785  delete gDirectory->FindObject(name);
786  if (bins->fN == 0) {
787  hlist[ipar] = new TH1D(name,title, nbins, outerAxis.GetXmin(), outerAxis.GetXmax());
788  } else {
789  hlist[ipar] = new TH1D(name,title, nbins,bins->fArray);
790  }
791  hlist[ipar]->GetXaxis()->SetTitle(outerAxis.GetTitle());
792  if (arr)
793  (*arr)[ipar] = hlist[ipar];
794  }
795  snprintf(name,2000,"%s_chi2",GetName());
796  delete gDirectory->FindObject(name);
797  TH1D *hchi2 = 0;
798  if (bins->fN == 0) {
799  hchi2 = new TH1D(name,"chisquare", nbins, outerAxis.GetXmin(), outerAxis.GetXmax());
800  } else {
801  hchi2 = new TH1D(name,"chisquare", nbins, bins->fArray);
802  }
803  hchi2->GetXaxis()->SetTitle(outerAxis.GetTitle());
804  if (arr)
805  (*arr)[npar] = hchi2;
806 
807  //Loop on all bins in Y, generate a projection along X
808  Int_t bin;
810  // in case of sliding merge nstep=1, i.e. do slices starting for every bin
811  // now do not slices case with overflow (makes more sense)
812  for (bin=firstbin;bin+ngroup-1<=lastbin;bin += nstep) {
813  TH1D *hp;
814  if (onX)
815  hp= ProjectionX("_temp",bin,bin+ngroup-1,"e");
816  else
817  hp= ProjectionY("_temp",bin,bin+ngroup-1,"e");
818  if (hp == 0) continue;
819  nentries = Long64_t(hp->GetEntries());
820  if (nentries == 0 || nentries < cut) {delete hp; continue;}
821  f1->SetParameters(parsave);
822  hp->Fit(f1,opt.Data());
823  Int_t npfits = f1->GetNumberFitPoints();
824  if (npfits > npar && npfits >= cut) {
825  Int_t binOn = bin + ngroup/2;
826  for (ipar=0;ipar<npar;ipar++) {
827  hlist[ipar]->Fill(outerAxis.GetBinCenter(binOn),f1->GetParameter(ipar));
828  hlist[ipar]->SetBinError(binOn,f1->GetParError(ipar));
829  }
830  hchi2->SetBinContent(binOn,f1->GetChisquare()/(npfits-npar));
831  }
832  delete hp;
833  }
834  delete [] parsave;
835  delete [] name;
836  delete [] title;
837  delete [] hlist;
838 }
839 
840 
841 ////////////////////////////////////////////////////////////////////////////////
842 /// Project slices along X in case of a 2-D histogram, then fit each slice
843 /// with function f1 and make a histogram for each fit parameter
844 /// Only bins along Y between firstybin and lastybin are considered.
845 /// By default (firstybin == 0, lastybin == -1), all bins in y including
846 /// over- and underflows are taken into account.
847 /// If f1=0, a gaussian is assumed
848 /// Before invoking this function, one can set a subrange to be fitted along X
849 /// via f1->SetRange(xmin,xmax)
850 /// The argument option (default="QNR") can be used to change the fit options.
851 /// - "Q" means Quiet mode
852 /// - "N" means do not show the result of the fit
853 /// - "R" means fit the function in the specified function range
854 /// - "G2" merge 2 consecutive bins along X
855 /// - "G3" merge 3 consecutive bins along X
856 /// - "G4" merge 4 consecutive bins along X
857 /// - "G5" merge 5 consecutive bins along X
858 /// - "S" sliding merge: merge n consecutive bins along X accordingly to what Gn is given.
859 /// It makes sense when used together with a Gn option
860 ///
861 /// The generated histograms are returned by adding them to arr, if arr is not NULL.
862 /// arr's SetOwner() is called, to signal that it is the user's respponsability to
863 /// delete the histograms, possibly by deleting the arrary.
864 /// ~~~ {.cpp}
865 /// TObjArray aSlices;
866 /// h2->FitSlicesX(func, 0, -1, 0, "QNR", &aSlices);
867 /// ~~~
868 /// will already delete the histograms once aSlice goes out of scope. aSlices will
869 /// contain the histogram for the i-th parameter of the fit function at aSlices[i];
870 /// aSlices[n] (n being the number of parameters) contains the chi2 distribution of
871 /// the fits.
872 ///
873 /// If arr is NULL, the generated histograms are added to the list of objects
874 /// in the current directory. It is the user's responsability to delete
875 /// these histograms.
876 ///
877 /// Example: Assume a 2-d histogram h2
878 /// ~~~ {.cpp}
879 /// Root > h2->FitSlicesX(); produces 4 TH1D histograms
880 /// with h2_0 containing parameter 0(Constant) for a Gaus fit
881 /// of each bin in Y projected along X
882 /// with h2_1 containing parameter 1(Mean) for a gaus fit
883 /// with h2_2 containing parameter 2(StdDev) for a gaus fit
884 /// with h2_chi2 containing the chisquare/number of degrees of freedom for a gaus fit
885 ///
886 /// Root > h2->FitSlicesX(0,15,22,10);
887 /// same as above, but only for bins 15 to 22 along Y
888 /// and only for bins in Y for which the corresponding projection
889 /// along X has more than cut bins filled.
890 /// ~~~
891 /// NOTE: To access the generated histograms in the current directory, do eg:
892 /// ~~~ {.cpp}
893 /// TH1D *h2_1 = (TH1D*)gDirectory->Get("h2_1");
894 /// ~~~
895 
896 void TH2::FitSlicesX(TF1 *f1, Int_t firstybin, Int_t lastybin, Int_t cut, Option_t *option, TObjArray* arr)
897 {
898  DoFitSlices(true, f1, firstybin, lastybin, cut, option, arr);
899 
900 }
901 
902 
903 ////////////////////////////////////////////////////////////////////////////////
904 /// Project slices along Y in case of a 2-D histogram, then fit each slice
905 /// with function f1 and make a histogram for each fit parameter
906 /// Only bins along X between firstxbin and lastxbin are considered.
907 /// By default (firstxbin == 0, lastxbin == -1), all bins in x including
908 /// over- and underflows are taken into account.
909 /// If f1=0, a gaussian is assumed
910 /// Before invoking this function, one can set a subrange to be fitted along Y
911 /// via f1->SetRange(ymin,ymax)
912 /// The argument option (default="QNR") can be used to change the fit options.
913 /// - "Q" means Quiet mode
914 /// - "N" means do not show the result of the fit
915 /// - "R" means fit the function in the specified function range
916 /// - "G2" merge 2 consecutive bins along Y
917 /// - "G3" merge 3 consecutive bins along Y
918 /// - "G4" merge 4 consecutive bins along Y
919 /// - "G5" merge 5 consecutive bins along Y
920 /// - "S" sliding merge: merge n consecutive bins along Y accordingly to what Gn is given.
921 /// It makes sense when used together with a Gn option
922 ///
923 /// The generated histograms are returned by adding them to arr, if arr is not NULL.
924 /// arr's SetOwner() is called, to signal that it is the user's respponsability to
925 /// delete the histograms, possibly by deleting the arrary.
926 /// ~~~ {.cpp}
927 /// TObjArray aSlices;
928 /// h2->FitSlicesY(func, 0, -1, 0, "QNR", &aSlices);
929 /// ~~~
930 /// will already delete the histograms once aSlice goes out of scope. aSlices will
931 /// contain the histogram for the i-th parameter of the fit function at aSlices[i];
932 /// aSlices[n] (n being the number of parameters) contains the chi2 distribution of
933 /// the fits.
934 ///
935 /// If arr is NULL, the generated histograms are added to the list of objects
936 /// in the current directory. It is the user's responsability to delete
937 /// these histograms.
938 ///
939 /// Example: Assume a 2-d histogram h2
940 /// ~~~ {.cpp}
941 /// Root > h2->FitSlicesY(); produces 4 TH1D histograms
942 /// with h2_0 containing parameter 0(Constant) for a Gaus fit
943 /// of each bin in X projected along Y
944 /// with h2_1 containing parameter 1(Mean) for a gaus fit
945 /// with h2_2 containing parameter 2(StdDev) for a gaus fit
946 /// with h2_chi2 containing the chisquare/number of degrees of freedom for a gaus fit
947 ///
948 /// Root > h2->FitSlicesY(0,15,22,10);
949 /// same as above, but only for bins 15 to 22 along X
950 /// and only for bins in X for which the corresponding projection
951 /// along Y has more than cut bins filled.
952 /// ~~~
953 ///
954 /// NOTE: To access the generated histograms in the current directory, do eg:
955 /// ~~~ {.cpp}
956 /// TH1D *h2_1 = (TH1D*)gDirectory->Get("h2_1");
957 /// ~~~
958 ///
959 /// A complete example of this function is given in tutorial:fitslicesy.C.
960 
961 void TH2::FitSlicesY(TF1 *f1, Int_t firstxbin, Int_t lastxbin, Int_t cut, Option_t *option, TObjArray* arr)
962 {
963  DoFitSlices(false, f1, firstxbin, lastxbin, cut, option, arr);
964 }
965 
966 Int_t TH2::GetBin(Int_t binx, Int_t biny, Int_t) const
967 {
968  // See comments in TH1::GetBin
969  Int_t ofy = fYaxis.GetNbins() + 1; // overflow bin
970  if (biny < 0) biny = 0;
971  if (biny > ofy) biny = ofy;
972 
973  return TH1::GetBin(binx) + (fXaxis.GetNbins() + 2) * biny;
974 }
975 
976 
977 ////////////////////////////////////////////////////////////////////////////////
978 /// compute first cell (binx,biny) in the range [firstxbin,lastxbin][firstybin,lastybin] for which
979 /// diff = abs(cell_content-c) <= maxdiff
980 /// In case several cells in the specified range with diff=0 are found
981 /// the first cell found is returned in binx,biny.
982 /// In case several cells in the specified range satisfy diff <=maxdiff
983 /// the cell with the smallest difference is returned in binx,biny.
984 /// In all cases the function returns the smallest difference.
985 ///
986 /// NOTE1: if firstxbin < 0, firstxbin is set to 1
987 /// if (lastxbin < firstxbin then lastxbin is set to the number of bins in X
988 /// ie if firstxbin=1 and lastxbin=0 (default) the search is on all bins in X except
989 /// for X's under- and overflow bins.
990 /// if firstybin < 0, firstybin is set to 1
991 /// if (lastybin < firstybin then lastybin is set to the number of bins in Y
992 /// ie if firstybin=1 and lastybin=0 (default) the search is on all bins in Y except
993 /// for Y's under- and overflow bins.
994 ///
995 /// NOTE2: if maxdiff=0 (default), the first cell with content=c is returned.
996 
997 Double_t TH2::GetBinWithContent2(Double_t c, Int_t &binx, Int_t &biny, Int_t firstxbin, Int_t lastxbin,
998  Int_t firstybin, Int_t lastybin, Double_t maxdiff) const
999 {
1000  if (fDimension != 2) {
1001  binx = -1;
1002  biny = -1;
1003  Error("GetBinWithContent2","function is only valid for 2-D histograms");
1004  return 0;
1005  }
1006  if (firstxbin < 0) firstxbin = 1;
1007  if (lastxbin < firstxbin) lastxbin = fXaxis.GetNbins();
1008  if (firstybin < 0) firstybin = 1;
1009  if (lastybin < firstybin) lastybin = fYaxis.GetNbins();
1010  Double_t diff, curmax = 1.e240;
1011  for (Int_t j = firstybin; j <= lastybin; j++) {
1012  for (Int_t i = firstxbin; i <= lastxbin; i++) {
1013  diff = TMath::Abs(GetBinContent(i,j)-c);
1014  if (diff <= 0) {binx = i; biny=j; return diff;}
1015  if (diff < curmax && diff <= maxdiff) {curmax = diff, binx=i; biny=j;}
1016  }
1017  }
1018  return curmax;
1019 }
1020 
1021 
1022 ////////////////////////////////////////////////////////////////////////////////
1023 /// Return correlation factor between axis1 and axis2.
1024 
1026 {
1027  if (axis1 < 1 || axis2 < 1 || axis1 > 2 || axis2 > 2) {
1028  Error("GetCorrelationFactor","Wrong parameters");
1029  return 0;
1030  }
1031  if (axis1 == axis2) return 1;
1032  Double_t stddev1 = GetStdDev(axis1);
1033  if (stddev1 == 0) return 0;
1034  Double_t stddev2 = GetStdDev(axis2);
1035  if (stddev2 == 0) return 0;
1036  return GetCovariance(axis1,axis2)/stddev1/stddev2;
1037 }
1038 
1039 
1040 ////////////////////////////////////////////////////////////////////////////////
1041 /// Return covariance between axis1 and axis2.
1042 
1044 {
1045  if (axis1 < 1 || axis2 < 1 || axis1 > 2 || axis2 > 2) {
1046  Error("GetCovariance","Wrong parameters");
1047  return 0;
1048  }
1049  Double_t stats[kNstat];
1050  GetStats(stats);
1051  Double_t sumw = stats[0];
1052  //Double_t sumw2 = stats[1];
1053  Double_t sumwx = stats[2];
1054  Double_t sumwx2 = stats[3];
1055  Double_t sumwy = stats[4];
1056  Double_t sumwy2 = stats[5];
1057  Double_t sumwxy = stats[6];
1058 
1059  if (sumw == 0) return 0;
1060  if (axis1 == 1 && axis2 == 1) {
1061  return TMath::Abs(sumwx2/sumw - sumwx/sumw*sumwx/sumw);
1062  }
1063  if (axis1 == 2 && axis2 == 2) {
1064  return TMath::Abs(sumwy2/sumw - sumwy/sumw*sumwy/sumw);
1065  }
1066  return sumwxy/sumw - sumwx/sumw*sumwy/sumw;
1067 }
1068 
1069 
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// Return 2 random numbers along axis x and y distributed according
1072 /// the cellcontents of a 2-dim histogram
1073 /// return a NaN if the histogram has a bin with negative content
1074 
1076 {
1077  Int_t nbinsx = GetNbinsX();
1078  Int_t nbinsy = GetNbinsY();
1079  Int_t nbins = nbinsx*nbinsy;
1080  Double_t integral;
1081  // compute integral checking that all bins have positive content (see ROOT-5894)
1082  if (fIntegral) {
1083  if (fIntegral[nbins+1] != fEntries) integral = ComputeIntegral(true);
1084  else integral = fIntegral[nbins];
1085  } else {
1086  integral = ComputeIntegral(true);
1087  }
1088  if (integral == 0 ) { x = 0; y = 0; return;}
1089  // case histogram has negative bins
1090  if (integral == TMath::QuietNaN() ) { x = TMath::QuietNaN(); y = TMath::QuietNaN(); return;}
1091 
1092  Double_t r1 = gRandom->Rndm();
1093  Int_t ibin = TMath::BinarySearch(nbins,fIntegral,(Double_t) r1);
1094  Int_t biny = ibin/nbinsx;
1095  Int_t binx = ibin - nbinsx*biny;
1096  x = fXaxis.GetBinLowEdge(binx+1);
1097  if (r1 > fIntegral[ibin]) x +=
1098  fXaxis.GetBinWidth(binx+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]);
1099  y = fYaxis.GetBinLowEdge(biny+1) + fYaxis.GetBinWidth(biny+1)*gRandom->Rndm();
1100 }
1101 
1102 
1103 ////////////////////////////////////////////////////////////////////////////////
1104 /// Fill the array stats from the contents of this histogram
1105 /// The array stats must be correctly dimensionned in the calling program.
1106 /// ~~~ {.cpp}
1107 /// stats[0] = sumw
1108 /// stats[1] = sumw2
1109 /// stats[2] = sumwx
1110 /// stats[3] = sumwx2
1111 /// stats[4] = sumwy
1112 /// stats[5] = sumwy2
1113 /// stats[6] = sumwxy
1114 /// ~~~
1115 ///
1116 /// If no axis-subranges are specified (via TAxis::SetRange), the array stats
1117 /// is simply a copy of the statistics quantities computed at filling time.
1118 /// If sub-ranges are specified, the function recomputes these quantities
1119 /// from the bin contents in the current axis ranges.
1120 ///
1121 /// Note that the mean value/StdDev is computed using the bins in the currently
1122 /// defined ranges (see TAxis::SetRange). By default the ranges include
1123 /// all bins from 1 to nbins included, excluding underflows and overflows.
1124 /// To force the underflows and overflows in the computation, one must
1125 /// call the static function TH1::StatOverflows(kTRUE) before filling
1126 /// the histogram.
1127 
1128 void TH2::GetStats(Double_t *stats) const
1129 {
1130  if (fBuffer) ((TH2*)this)->BufferEmpty();
1131 
1133  std::fill(stats, stats + 7, 0);
1134 
1135  Int_t firstBinX = fXaxis.GetFirst();
1136  Int_t lastBinX = fXaxis.GetLast();
1137  Int_t firstBinY = fYaxis.GetFirst();
1138  Int_t lastBinY = fYaxis.GetLast();
1139  // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
1140  if (fgStatOverflows) {
1141  if ( !fXaxis.TestBit(TAxis::kAxisRange) ) {
1142  if (firstBinX == 1) firstBinX = 0;
1143  if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1;
1144  }
1145  if ( !fYaxis.TestBit(TAxis::kAxisRange) ) {
1146  if (firstBinY == 1) firstBinY = 0;
1147  if (lastBinY == fYaxis.GetNbins() ) lastBinY += 1;
1148  }
1149  }
1150  for (Int_t biny = firstBinY; biny <= lastBinY; ++biny) {
1151  Double_t y = fYaxis.GetBinCenter(biny);
1152  for (Int_t binx = firstBinX; binx <= lastBinX; ++binx) {
1153  Double_t x = fXaxis.GetBinCenter(binx);
1154  //w = TMath::Abs(GetBinContent(bin));
1155  Int_t bin = GetBin(binx,biny);
1156  Double_t w = RetrieveBinContent(bin);
1157  Double_t wx = w * x; // avoid some extra multiplications at the expense of some clarity
1158  Double_t wy = w * y;
1159 
1160  stats[0] += w;
1161  stats[1] += GetBinErrorSqUnchecked(bin);
1162  stats[2] += wx;
1163  stats[3] += wx * x;
1164  stats[4] += wy;
1165  stats[5] += wy * y;
1166  stats[6] += wx * y;
1167  }
1168  }
1169  } else {
1170  stats[0] = fTsumw;
1171  stats[1] = fTsumw2;
1172  stats[2] = fTsumwx;
1173  stats[3] = fTsumwx2;
1174  stats[4] = fTsumwy;
1175  stats[5] = fTsumwy2;
1176  stats[6] = fTsumwxy;
1177  }
1178 }
1179 
1180 
1181 ////////////////////////////////////////////////////////////////////////////////
1182 /// Return integral of bin contents. Only bins in the bins range are considered.
1183 /// By default the integral is computed as the sum of bin contents in the range.
1184 /// if option "width" is specified, the integral is the sum of
1185 /// the bin contents multiplied by the bin width in x and in y.
1186 
1188 {
1189  return Integral(fXaxis.GetFirst(),fXaxis.GetLast(),
1190  fYaxis.GetFirst(),fYaxis.GetLast(),option);
1191 }
1192 
1193 
1194 ////////////////////////////////////////////////////////////////////////////////
1195 /// Return integral of bin contents in range [firstxbin,lastxbin],[firstybin,lastybin]
1196 /// for a 2-D histogram
1197 /// By default the integral is computed as the sum of bin contents in the range.
1198 /// if option "width" is specified, the integral is the sum of
1199 /// the bin contents multiplied by the bin width in x and in y.
1200 
1201 Double_t TH2::Integral(Int_t firstxbin, Int_t lastxbin, Int_t firstybin, Int_t lastybin, Option_t *option) const
1202 {
1203  double err = 0;
1204  return DoIntegral(firstxbin,lastxbin,firstybin,lastybin,-1,0,err,option);
1205 }
1206 
1207 
1208 ////////////////////////////////////////////////////////////////////////////////
1209 /// Return integral of bin contents in range [firstxbin,lastxbin],[firstybin,lastybin]
1210 /// for a 2-D histogram. Calculates also the integral error using error propagation
1211 /// from the bin errors assumming that all the bins are uncorrelated.
1212 /// By default the integral is computed as the sum of bin contents in the range.
1213 /// if option "width" is specified, the integral is the sum of
1214 /// the bin contents multiplied by the bin width in x and in y.
1215 
1216 Double_t TH2::IntegralAndError(Int_t firstxbin, Int_t lastxbin, Int_t firstybin, Int_t lastybin, Double_t & error, Option_t *option) const
1217 {
1218  return DoIntegral(firstxbin,lastxbin,firstybin,lastybin,-1,0,error,option,kTRUE);
1219 }
1220 
1221 
1222 ////////////////////////////////////////////////////////////////////////////////
1223 ///illegal for a TH2
1224 
1226 {
1227  Error("Interpolate","This function must be called with 2 arguments for a TH2");
1228  return 0;
1229 }
1230 
1231 
1232 ////////////////////////////////////////////////////////////////////////////////
1233 /// Given a point P(x,y), Interpolate approximates the value via bilinear
1234 /// interpolation based on the four nearest bin centers
1235 /// see Wikipedia, Bilinear Interpolation
1236 /// Andy Mastbaum 10/8/2008
1237 /// vaguely based on R.Raja 6-Sep-2008
1238 
1240 {
1241  Double_t f=0;
1242  Double_t x1=0,x2=0,y1=0,y2=0;
1243  Double_t dx,dy;
1244  Int_t bin_x = fXaxis.FindBin(x);
1245  Int_t bin_y = fYaxis.FindBin(y);
1246  if(bin_x<1 || bin_x>GetNbinsX() || bin_y<1 || bin_y>GetNbinsY()) {
1247  Error("Interpolate","Cannot interpolate outside histogram domain.");
1248  return 0;
1249  }
1250  Int_t quadrant = 0; // CCW from UR 1,2,3,4
1251  // which quadrant of the bin (bin_P) are we in?
1252  dx = fXaxis.GetBinUpEdge(bin_x)-x;
1253  dy = fYaxis.GetBinUpEdge(bin_y)-y;
1254  if (dx<=fXaxis.GetBinWidth(bin_x)/2 && dy<=fYaxis.GetBinWidth(bin_y)/2)
1255  quadrant = 1; // upper right
1256  if (dx>fXaxis.GetBinWidth(bin_x)/2 && dy<=fYaxis.GetBinWidth(bin_y)/2)
1257  quadrant = 2; // upper left
1258  if (dx>fXaxis.GetBinWidth(bin_x)/2 && dy>fYaxis.GetBinWidth(bin_y)/2)
1259  quadrant = 3; // lower left
1260  if (dx<=fXaxis.GetBinWidth(bin_x)/2 && dy>fYaxis.GetBinWidth(bin_y)/2)
1261  quadrant = 4; // lower right
1262  switch(quadrant) {
1263  case 1:
1264  x1 = fXaxis.GetBinCenter(bin_x);
1265  y1 = fYaxis.GetBinCenter(bin_y);
1266  x2 = fXaxis.GetBinCenter(bin_x+1);
1267  y2 = fYaxis.GetBinCenter(bin_y+1);
1268  break;
1269  case 2:
1270  x1 = fXaxis.GetBinCenter(bin_x-1);
1271  y1 = fYaxis.GetBinCenter(bin_y);
1272  x2 = fXaxis.GetBinCenter(bin_x);
1273  y2 = fYaxis.GetBinCenter(bin_y+1);
1274  break;
1275  case 3:
1276  x1 = fXaxis.GetBinCenter(bin_x-1);
1277  y1 = fYaxis.GetBinCenter(bin_y-1);
1278  x2 = fXaxis.GetBinCenter(bin_x);
1279  y2 = fYaxis.GetBinCenter(bin_y);
1280  break;
1281  case 4:
1282  x1 = fXaxis.GetBinCenter(bin_x);
1283  y1 = fYaxis.GetBinCenter(bin_y-1);
1284  x2 = fXaxis.GetBinCenter(bin_x+1);
1285  y2 = fYaxis.GetBinCenter(bin_y);
1286  break;
1287  }
1288  Int_t bin_x1 = fXaxis.FindBin(x1);
1289  if(bin_x1<1) bin_x1=1;
1290  Int_t bin_x2 = fXaxis.FindBin(x2);
1291  if(bin_x2>GetNbinsX()) bin_x2=GetNbinsX();
1292  Int_t bin_y1 = fYaxis.FindBin(y1);
1293  if(bin_y1<1) bin_y1=1;
1294  Int_t bin_y2 = fYaxis.FindBin(y2);
1295  if(bin_y2>GetNbinsY()) bin_y2=GetNbinsY();
1296  Int_t bin_q22 = GetBin(bin_x2,bin_y2);
1297  Int_t bin_q12 = GetBin(bin_x1,bin_y2);
1298  Int_t bin_q11 = GetBin(bin_x1,bin_y1);
1299  Int_t bin_q21 = GetBin(bin_x2,bin_y1);
1300  Double_t q11 = RetrieveBinContent(bin_q11);
1301  Double_t q12 = RetrieveBinContent(bin_q12);
1302  Double_t q21 = RetrieveBinContent(bin_q21);
1303  Double_t q22 = RetrieveBinContent(bin_q22);
1304  Double_t d = 1.0*(x2-x1)*(y2-y1);
1305  f = 1.0*q11/d*(x2-x)*(y2-y)+1.0*q21/d*(x-x1)*(y2-y)+1.0*q12/d*(x2-x)*(y-y1)+1.0*q22/d*(x-x1)*(y-y1);
1306  return f;
1307 }
1308 
1309 
1310 ////////////////////////////////////////////////////////////////////////////////
1311 ///illegal for a TH2
1312 
1314 {
1315  Error("Interpolate","This function must be called with 2 arguments for a TH2");
1316  return 0;
1317 }
1318 
1319 
1320 ////////////////////////////////////////////////////////////////////////////////
1321 /// Statistical test of compatibility in shape between
1322 /// THIS histogram and h2, using Kolmogorov test.
1323 /// Default: Ignore under- and overflow bins in comparison
1324 ///
1325 /// option is a character string to specify options
1326 /// - "U" include Underflows in test
1327 /// - "O" include Overflows
1328 /// - "N" include comparison of normalizations
1329 /// - "D" Put out a line of "Debug" printout
1330 /// - "M" Return the Maximum Kolmogorov distance instead of prob
1331 ///
1332 /// The returned function value is the probability of test
1333 /// (much less than one means NOT compatible)
1334 ///
1335 /// The KS test uses the distance between the pseudo-CDF's obtained
1336 /// from the histogram. Since in 2D the order for generating the pseudo-CDF is
1337 /// arbitrary, two pairs of pseudo-CDF are used, one starting from the x axis the
1338 /// other from the y axis and the maximum distance is the average of the two maximum
1339 /// distances obtained.
1340 ///
1341 /// Code adapted by Rene Brun from original HBOOK routine HDIFF
1342 
1343 Double_t TH2::KolmogorovTest(const TH1 *h2, Option_t *option) const
1344 {
1345  TString opt = option;
1346  opt.ToUpper();
1347 
1348  Double_t prb = 0;
1349  TH1 *h1 = (TH1*)this;
1350  if (h2 == 0) return 0;
1351  const TAxis *xaxis1 = h1->GetXaxis();
1352  const TAxis *xaxis2 = h2->GetXaxis();
1353  const TAxis *yaxis1 = h1->GetYaxis();
1354  const TAxis *yaxis2 = h2->GetYaxis();
1355  Int_t ncx1 = xaxis1->GetNbins();
1356  Int_t ncx2 = xaxis2->GetNbins();
1357  Int_t ncy1 = yaxis1->GetNbins();
1358  Int_t ncy2 = yaxis2->GetNbins();
1359 
1360  // Check consistency of dimensions
1361  if (h1->GetDimension() != 2 || h2->GetDimension() != 2) {
1362  Error("KolmogorovTest","Histograms must be 2-D\n");
1363  return 0;
1364  }
1365 
1366  // Check consistency in number of channels
1367  if (ncx1 != ncx2) {
1368  Error("KolmogorovTest","Number of channels in X is different, %d and %d\n",ncx1,ncx2);
1369  return 0;
1370  }
1371  if (ncy1 != ncy2) {
1372  Error("KolmogorovTest","Number of channels in Y is different, %d and %d\n",ncy1,ncy2);
1373  return 0;
1374  }
1375 
1376  // Check consistency in channel edges
1377  Bool_t afunc1 = kFALSE;
1378  Bool_t afunc2 = kFALSE;
1379  Double_t difprec = 1e-5;
1380  Double_t diff1 = TMath::Abs(xaxis1->GetXmin() - xaxis2->GetXmin());
1381  Double_t diff2 = TMath::Abs(xaxis1->GetXmax() - xaxis2->GetXmax());
1382  if (diff1 > difprec || diff2 > difprec) {
1383  Error("KolmogorovTest","histograms with different binning along X");
1384  return 0;
1385  }
1386  diff1 = TMath::Abs(yaxis1->GetXmin() - yaxis2->GetXmin());
1387  diff2 = TMath::Abs(yaxis1->GetXmax() - yaxis2->GetXmax());
1388  if (diff1 > difprec || diff2 > difprec) {
1389  Error("KolmogorovTest","histograms with different binning along Y");
1390  return 0;
1391  }
1392 
1393  // Should we include Uflows, Oflows?
1394  Int_t ibeg = 1, jbeg = 1;
1395  Int_t iend = ncx1, jend = ncy1;
1396  if (opt.Contains("U")) {ibeg = 0; jbeg = 0;}
1397  if (opt.Contains("O")) {iend = ncx1+1; jend = ncy1+1;}
1398 
1399  Int_t i,j;
1400  Double_t sum1 = 0;
1401  Double_t sum2 = 0;
1402  Double_t w1 = 0;
1403  Double_t w2 = 0;
1404  for (i = ibeg; i <= iend; i++) {
1405  for (j = jbeg; j <= jend; j++) {
1406  sum1 += h1->GetBinContent(i,j);
1407  sum2 += h2->GetBinContent(i,j);
1408  Double_t ew1 = h1->GetBinError(i,j);
1409  Double_t ew2 = h2->GetBinError(i,j);
1410  w1 += ew1*ew1;
1411  w2 += ew2*ew2;
1412 
1413  }
1414  }
1415 
1416  // Check that both scatterplots contain events
1417  if (sum1 == 0) {
1418  Error("KolmogorovTest","Integral is zero for h1=%s\n",h1->GetName());
1419  return 0;
1420  }
1421  if (sum2 == 0) {
1422  Error("KolmogorovTest","Integral is zero for h2=%s\n",h2->GetName());
1423  return 0;
1424  }
1425  // calculate the effective entries.
1426  // the case when errors are zero (w1 == 0 or w2 ==0) are equivalent to
1427  // compare to a function. In that case the rescaling is done only on sqrt(esum2) or sqrt(esum1)
1428  Double_t esum1 = 0, esum2 = 0;
1429  if (w1 > 0)
1430  esum1 = sum1 * sum1 / w1;
1431  else
1432  afunc1 = kTRUE; // use later for calculating z
1433 
1434  if (w2 > 0)
1435  esum2 = sum2 * sum2 / w2;
1436  else
1437  afunc2 = kTRUE; // use later for calculating z
1438 
1439  if (afunc2 && afunc1) {
1440  Error("KolmogorovTest","Errors are zero for both histograms\n");
1441  return 0;
1442  }
1443 
1444  // Find first Kolmogorov distance
1445  Double_t s1 = 1/sum1;
1446  Double_t s2 = 1/sum2;
1447  Double_t dfmax1 = 0;
1448  Double_t rsum1=0, rsum2=0;
1449  for (i=ibeg;i<=iend;i++) {
1450  for (j=jbeg;j<=jend;j++) {
1451  rsum1 += s1*h1->GetBinContent(i,j);
1452  rsum2 += s2*h2->GetBinContent(i,j);
1453  dfmax1 = TMath::Max(dfmax1, TMath::Abs(rsum1-rsum2));
1454  }
1455  }
1456 
1457  // Find second Kolmogorov distance
1458  Double_t dfmax2 = 0;
1459  rsum1=0, rsum2=0;
1460  for (j=jbeg;j<=jend;j++) {
1461  for (i=ibeg;i<=iend;i++) {
1462  rsum1 += s1*h1->GetBinContent(i,j);
1463  rsum2 += s2*h2->GetBinContent(i,j);
1464  dfmax2 = TMath::Max(dfmax2, TMath::Abs(rsum1-rsum2));
1465  }
1466  }
1467 
1468  // Get Kolmogorov probability: use effective entries, esum1 or esum2, for normalizing it
1469  Double_t factnm;
1470  if (afunc1) factnm = TMath::Sqrt(esum2);
1471  else if (afunc2) factnm = TMath::Sqrt(esum1);
1472  else factnm = TMath::Sqrt(esum1*sum2/(esum1+esum2));
1473 
1474  // take average of the two distances
1475  Double_t dfmax = 0.5*(dfmax1+dfmax2);
1476  Double_t z = dfmax*factnm;
1477 
1478  prb = TMath::KolmogorovProb(z);
1479 
1480  Double_t prb1 = 0, prb2 = 0;
1481  // option N to combine normalization makes sense if both afunc1 and afunc2 are false
1482  if (opt.Contains("N") && !(afunc1 || afunc2 ) ) {
1483  // Combine probabilities for shape and normalization
1484  prb1 = prb;
1485  Double_t d12 = esum1-esum2;
1486  Double_t chi2 = d12*d12/(esum1+esum2);
1487  prb2 = TMath::Prob(chi2,1);
1488  // see Eadie et al., section 11.6.2
1489  if (prb > 0 && prb2 > 0) prb = prb*prb2*(1-TMath::Log(prb*prb2));
1490  else prb = 0;
1491  }
1492 
1493  // debug printout
1494  if (opt.Contains("D")) {
1495  printf(" Kolmo Prob h1 = %s, sum1=%g\n",h1->GetName(),sum1);
1496  printf(" Kolmo Prob h2 = %s, sum2=%g\n",h2->GetName(),sum2);
1497  printf(" Kolmo Probabil = %f, Max Dist = %g\n",prb,dfmax);
1498  if (opt.Contains("N"))
1499  printf(" Kolmo Probabil = %f for shape alone, =%f for normalisation alone\n",prb1,prb2);
1500  }
1501  // This numerical error condition should never occur:
1502  if (TMath::Abs(rsum1-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h1=%s\n",h1->GetName());
1503  if (TMath::Abs(rsum2-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h2=%s\n",h2->GetName());
1504 
1505  if(opt.Contains("M")) return dfmax; // return avergae of max distance
1506 
1507  return prb;
1508 }
1509 
1510 
1511 ////////////////////////////////////////////////////////////////////////////////
1512 /// Rebin only the X axis
1513 /// see Rebin2D
1514 
1515 TH2 *TH2::RebinX(Int_t ngroup, const char *newname)
1516 {
1517  return Rebin2D(ngroup, 1, newname);
1518 }
1519 
1520 
1521 ////////////////////////////////////////////////////////////////////////////////
1522 /// Rebin only the Y axis
1523 /// see Rebin2D
1524 
1525 TH2 *TH2::RebinY(Int_t ngroup, const char *newname)
1526 {
1527  return Rebin2D(1, ngroup, newname);
1528 }
1529 
1530 
1531 ////////////////////////////////////////////////////////////////////////////////
1532 /// Rebin this histogram grouping nxgroup/nygroup bins along the xaxis/yaxis together.
1533 ///
1534 /// if newname is not blank a new temporary histogram hnew is created.
1535 /// else the current histogram is modified (default)
1536 /// The parameter nxgroup/nygroup indicate how many bins along the xaxis/yaxis of this
1537 /// have to me merged into one bin of hnew
1538 /// If the original histogram has errors stored (via Sumw2), the resulting
1539 /// histograms has new errors correctly calculated.
1540 ///
1541 /// examples: if hpxpy is an existing TH2 histogram with 40 x 40 bins
1542 /// ~~~ {.cpp}
1543 /// hpxpy->Rebin2D(); // merges two bins along the xaxis and yaxis in one in hpxpy
1544 /// // Carefull: previous contents of hpxpy are lost
1545 /// hpxpy->RebinX(5); //merges five bins along the xaxis in one in hpxpy
1546 /// TH2 *hnew = hpxpy->RebinY(5,"hnew"); // creates a new histogram hnew
1547 /// // merging 5 bins of h1 along the yaxis in one bin
1548 /// ~~~
1549 ///
1550 /// NOTE : If nxgroup/nygroup is not an exact divider of the number of bins,
1551 /// along the xaxis/yaxis the top limit(s) of the rebinned histogram
1552 /// is changed to the upper edge of the xbin=newxbins*nxgroup resp.
1553 /// ybin=newybins*nygroup and the corresponding bins are added to
1554 /// the overflow bin.
1555 /// Statistics will be recomputed from the new bin contents.
1556 
1557 TH2 *TH2::Rebin2D(Int_t nxgroup, Int_t nygroup, const char *newname)
1558 {
1559  Int_t nxbins = fXaxis.GetNbins();
1560  Int_t nybins = fYaxis.GetNbins();
1561  Int_t nx = nxbins + 2; // normal bins + underflow and overflow
1562  Int_t ny = nybins + 2;
1567 
1568  if (GetDimension() != 2) {
1569  Error("Rebin2D", "Histogram must be TH2. This histogram has %d dimensions.", GetDimension());
1570  return 0;
1571  }
1572  if ((nxgroup <= 0) || (nxgroup > nxbins)) {
1573  Error("Rebin2D", "Illegal value of nxgroup=%d",nxgroup);
1574  return 0;
1575  }
1576  if ((nygroup <= 0) || (nygroup > nybins)) {
1577  Error("Rebin2D", "Illegal value of nygroup=%d",nygroup);
1578  return 0;
1579  }
1580 
1581  Int_t newxbins = nxbins / nxgroup;
1582  Int_t newybins = nybins / nygroup;
1583  Int_t newnx = newxbins + 2; // regular bins + overflow / underflow
1584  Int_t newny = newybins + 2; // regular bins + overflow / underflow
1585 
1586  // Save old bin contents into a new array
1587  Double_t *oldBins = new Double_t[fNcells];
1588  for (Int_t i = 0; i < fNcells; ++i) oldBins[i] = RetrieveBinContent(i);
1589 
1590  Double_t* oldErrors = NULL;
1591  if (fSumw2.fN) {
1592  oldErrors = new Double_t[fNcells];
1593  for (Int_t i = 0; i < fNcells; ++i) oldErrors[i] = GetBinErrorSqUnchecked(i);
1594  }
1595 
1596  // create a clone of the old histogram if newname is specified
1597  TH2* hnew = this;
1598  if (newname && strlen(newname)) {
1599  hnew = (TH2*)Clone();
1600  hnew->SetName(newname);
1601  }
1602 
1603  bool resetStat = false;
1604 
1605  // change axis specs and rebuild bin contents array
1606  if(newxbins * nxgroup != nxbins) {
1607  xmax = fXaxis.GetBinUpEdge(newxbins * nxgroup);
1608  resetStat = true; // stats must be reset because top bins will be moved to overflow bin
1609  }
1610  if(newybins * nygroup != nybins) {
1611  ymax = fYaxis.GetBinUpEdge(newybins * nygroup);
1612  resetStat = true; // stats must be reset because top bins will be moved to overflow bin
1613  }
1614 
1615  // save the TAttAxis members (reset by SetBins) for x axis
1616  Int_t nXdivisions = fXaxis.GetNdivisions();
1617  Color_t xAxisColor = fXaxis.GetAxisColor();
1618  Color_t xLabelColor = fXaxis.GetLabelColor();
1619  Style_t xLabelFont = fXaxis.GetLabelFont();
1620  Float_t xLabelOffset = fXaxis.GetLabelOffset();
1621  Float_t xLabelSize = fXaxis.GetLabelSize();
1622  Float_t xTickLength = fXaxis.GetTickLength();
1623  Float_t xTitleOffset = fXaxis.GetTitleOffset();
1624  Float_t xTitleSize = fXaxis.GetTitleSize();
1625  Color_t xTitleColor = fXaxis.GetTitleColor();
1626  Style_t xTitleFont = fXaxis.GetTitleFont();
1627  // save the TAttAxis members (reset by SetBins) for y axis
1628  Int_t nYdivisions = fYaxis.GetNdivisions();
1629  Color_t yAxisColor = fYaxis.GetAxisColor();
1630  Color_t yLabelColor = fYaxis.GetLabelColor();
1631  Style_t yLabelFont = fYaxis.GetLabelFont();
1632  Float_t yLabelOffset = fYaxis.GetLabelOffset();
1633  Float_t yLabelSize = fYaxis.GetLabelSize();
1634  Float_t yTickLength = fYaxis.GetTickLength();
1635  Float_t yTitleOffset = fYaxis.GetTitleOffset();
1636  Float_t yTitleSize = fYaxis.GetTitleSize();
1637  Color_t yTitleColor = fYaxis.GetTitleColor();
1638  Style_t yTitleFont = fYaxis.GetTitleFont();
1639 
1640 
1641  // copy merged bin contents (ignore under/overflows)
1642  if (nxgroup != 1 || nygroup != 1) {
1643  if(fXaxis.GetXbins()->GetSize() > 0 || fYaxis.GetXbins()->GetSize() > 0){
1644  // variable bin sizes in x or y, don't treat both cases separately
1645  Double_t *xbins = new Double_t[newxbins + 1];
1646  for(Int_t i = 0; i <= newxbins; ++i) xbins[i] = fXaxis.GetBinLowEdge(1 + i * nxgroup);
1647  Double_t *ybins = new Double_t[newybins + 1];
1648  for(Int_t i = 0; i <= newybins; ++i) ybins[i] = fYaxis.GetBinLowEdge(1 + i * nygroup);
1649  hnew->SetBins(newxbins, xbins, newybins, ybins); // changes also errors array (if any)
1650  delete [] xbins;
1651  delete [] ybins;
1652  } else {
1653  hnew->SetBins(newxbins, xmin, xmax, newybins, ymin, ymax); //changes also errors array
1654  }
1655 
1656  // (0, 0): x - underflow; y - underflow
1657  hnew->UpdateBinContent(0, oldBins[0]);
1658  if (oldErrors) hnew->fSumw2[0] = 0;
1659 
1660  // (x, 0): x - regular / overflow; y - underflow
1661  for(Int_t binx = 1, oldbinx = 1; binx < newnx; ++binx, oldbinx += nxgroup){
1662  Double_t binContent = 0.0, binErrorSq = 0.0;
1663  for (Int_t i = 0; i < nxgroup && (oldbinx + i) < nx; ++i) {
1664  Int_t bin = oldbinx + i;
1665  binContent += oldBins[bin];
1666  if(oldErrors) binErrorSq += oldErrors[bin];
1667  }
1668  Int_t newbin = binx;
1669  hnew->UpdateBinContent(newbin, binContent);
1670  if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
1671  }
1672 
1673  // (0, y): x - underflow; y - regular / overflow
1674  for(Int_t biny = 1, oldbiny = 1; biny < newny; ++biny, oldbiny += nygroup){
1675  Double_t binContent = 0.0, binErrorSq = 0.0;
1676  for (Int_t j = 0; j < nygroup && (oldbiny + j) < ny; ++j) {
1677  Int_t bin = (oldbiny + j) * nx;
1678  binContent += oldBins[bin];
1679  if(oldErrors) binErrorSq += oldErrors[bin];
1680  }
1681  Int_t newbin = biny * newnx;
1682  hnew->UpdateBinContent(newbin, binContent);
1683  if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
1684  }
1685 
1686  // (x, y): x - regular / overflow; y - regular / overflow
1687  for (Int_t binx = 1, oldbinx = 1; binx < newnx; ++binx, oldbinx += nxgroup) {
1688  for (Int_t biny = 1, oldbiny = 1; biny < newny; ++biny, oldbiny += nygroup) {
1689  Double_t binContent = 0.0, binErrorSq = 0.0;
1690  for (Int_t i = 0; i < nxgroup && (oldbinx + i) < nx; ++i) {
1691  for (Int_t j = 0; j < nygroup && (oldbiny + j) < ny; ++j) {
1692  Int_t bin = oldbinx + i + (oldbiny + j) * nx;
1693  binContent += oldBins[bin];
1694  if (oldErrors) binErrorSq += oldErrors[bin];
1695  }
1696  }
1697  Int_t newbin = binx + biny * newnx;
1698  hnew->UpdateBinContent(newbin, binContent);
1699  if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
1700  }
1701  }
1702  }
1703 
1704  // Restore x axis attributes
1705  fXaxis.SetNdivisions(nXdivisions);
1706  fXaxis.SetAxisColor(xAxisColor);
1707  fXaxis.SetLabelColor(xLabelColor);
1708  fXaxis.SetLabelFont(xLabelFont);
1709  fXaxis.SetLabelOffset(xLabelOffset);
1710  fXaxis.SetLabelSize(xLabelSize);
1711  fXaxis.SetTickLength(xTickLength);
1712  fXaxis.SetTitleOffset(xTitleOffset);
1713  fXaxis.SetTitleSize(xTitleSize);
1714  fXaxis.SetTitleColor(xTitleColor);
1715  fXaxis.SetTitleFont(xTitleFont);
1716  // Restore y axis attributes
1717  fYaxis.SetNdivisions(nYdivisions);
1718  fYaxis.SetAxisColor(yAxisColor);
1719  fYaxis.SetLabelColor(yLabelColor);
1720  fYaxis.SetLabelFont(yLabelFont);
1721  fYaxis.SetLabelOffset(yLabelOffset);
1722  fYaxis.SetLabelSize(yLabelSize);
1723  fYaxis.SetTickLength(yTickLength);
1724  fYaxis.SetTitleOffset(yTitleOffset);
1725  fYaxis.SetTitleSize(yTitleSize);
1726  fYaxis.SetTitleColor(yTitleColor);
1727  fYaxis.SetTitleFont(yTitleFont);
1728 
1729  if (resetStat) hnew->ResetStats();
1730 
1731  delete [] oldBins;
1732  if (oldErrors) delete [] oldErrors;
1733  return hnew;
1734 }
1735 
1736 
1737 ////////////////////////////////////////////////////////////////////////////////
1738 
1739 TProfile *TH2::DoProfile(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
1740 {
1741  TString opt = option;
1742  // extract cut infor
1743  TString cut;
1744  Int_t i1 = opt.Index("[");
1745  if (i1>=0) {
1746  Int_t i2 = opt.Index("]");
1747  cut = opt(i1,i2-i1+1);
1748  }
1749  opt.ToLower();
1750  bool originalRange = opt.Contains("o");
1751 
1752  const TAxis& outAxis = ( onX ? fXaxis : fYaxis );
1753  const TAxis& inAxis = ( onX ? fYaxis : fXaxis );
1754  Int_t inN = inAxis.GetNbins();
1755  const char *expectedName = ( onX ? "_pfx" : "_pfy" );
1756 
1757  Int_t firstOutBin, lastOutBin;
1758  firstOutBin = outAxis.GetFirst();
1759  lastOutBin = outAxis.GetLast();
1760  if (firstOutBin == 0 && lastOutBin == 0) {
1761  firstOutBin = 1; lastOutBin = outAxis.GetNbins();
1762  }
1763 
1764  if ( lastbin < firstbin && inAxis.TestBit(TAxis::kAxisRange) ) {
1765  firstbin = inAxis.GetFirst();
1766  lastbin = inAxis.GetLast();
1767  // For special case of TAxis::SetRange, when first == 1 and last
1768  // = N and the range bit has been set, the TAxis will return 0
1769  // for both.
1770  if (firstbin == 0 && lastbin == 0)
1771  {
1772  firstbin = 1;
1773  lastbin = inAxis.GetNbins();
1774  }
1775  }
1776  if (firstbin < 0) firstbin = 1;
1777  if (lastbin < 0) lastbin = inN;
1778  if (lastbin > inN+1) lastbin = inN;
1779 
1780  // Create the profile histogram
1781  char *pname = (char*)name;
1782  if (name && strcmp(name, expectedName) == 0) {
1783  Int_t nch = strlen(GetName()) + 5;
1784  pname = new char[nch];
1785  snprintf(pname,nch,"%s%s",GetName(),name);
1786  }
1787  TProfile *h1=0;
1788  //check if a profile with identical name exist
1789  // if compatible reset and re-use previous histogram
1790  TObject *h1obj = gROOT->FindObject(pname);
1791  if (h1obj && h1obj->InheritsFrom(TH1::Class())) {
1792  if (h1obj->IsA() != TProfile::Class() ) {
1793  Error("DoProfile","Histogram with name %s must be a TProfile and is a %s",name,h1obj->ClassName());
1794  return 0;
1795  }
1796  h1 = (TProfile*)h1obj;
1797  // reset the existing histogram and set always the new binning for the axis
1798  // This avoid problems when the histogram already exists and the histograms is rebinned or its range has changed
1799  // (see https://savannah.cern.ch/bugs/?94101 or https://savannah.cern.ch/bugs/?95808 )
1800  h1->Reset();
1801  const TArrayD *xbins = outAxis.GetXbins();
1802  if (xbins->fN == 0) {
1803  if ( originalRange )
1804  h1->SetBins(outAxis.GetNbins(),outAxis.GetXmin(),outAxis.GetXmax());
1805  else
1806  h1->SetBins(lastOutBin-firstOutBin+1,outAxis.GetBinLowEdge(firstOutBin),outAxis.GetBinUpEdge(lastOutBin));
1807  } else {
1808  // case variable bins
1809  if (originalRange )
1810  h1->SetBins(outAxis.GetNbins(),xbins->fArray);
1811  else
1812  h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);
1813  }
1814  }
1815 
1816  Int_t ncuts = 0;
1817  if (opt.Contains("[")) {
1818  ((TH2 *)this)->GetPainter();
1819  if (fPainter) ncuts = fPainter->MakeCuts((char*)cut.Data());
1820  }
1821 
1822  if (!h1) {
1823  const TArrayD *bins = outAxis.GetXbins();
1824  if (bins->fN == 0) {
1825  if ( originalRange )
1826  h1 = new TProfile(pname,GetTitle(),outAxis.GetNbins(),outAxis.GetXmin(),outAxis.GetXmax(),opt);
1827  else
1828  h1 = new TProfile(pname,GetTitle(),lastOutBin-firstOutBin+1,
1829  outAxis.GetBinLowEdge(firstOutBin),
1830  outAxis.GetBinUpEdge(lastOutBin), opt);
1831  } else {
1832  // case variable bins
1833  if (originalRange )
1834  h1 = new TProfile(pname,GetTitle(),outAxis.GetNbins(),bins->fArray,opt);
1835  else
1836  h1 = new TProfile(pname,GetTitle(),lastOutBin-firstOutBin+1,&bins->fArray[firstOutBin-1],opt);
1837  }
1838  }
1839  if (pname != name) delete [] pname;
1840 
1841  // Copy attributes
1842  h1->GetXaxis()->ImportAttributes( &outAxis);
1843  h1->SetLineColor(this->GetLineColor());
1844  h1->SetFillColor(this->GetFillColor());
1845  h1->SetMarkerColor(this->GetMarkerColor());
1846  h1->SetMarkerStyle(this->GetMarkerStyle());
1847 
1848  // check if histogram is weighted
1849  // in case need to store sum of weight square/bin for the profile
1850  bool useWeights = (GetSumw2N() > 0);
1851  if (useWeights) h1->Sumw2();
1852  // we need to set this bit because we fill the profile using a single Fill for many entries
1853  // This is needed for the changes applied to make automatically the histogram weighted in ROOT 6 versions
1854  else h1->SetBit(TH1::kIsNotW);
1855 
1856  // Fill the profile histogram
1857  // no entries/bin is available so can fill only using bin content as weight
1858  Double_t totcont = 0;
1859  TArrayD & binSumw2 = *(h1->GetBinSumw2());
1860 
1861  // implement filling of projected histogram
1862  // outbin is bin number of outAxis (the projected axis). Loop is done on all bin of TH2 histograms
1863  // inbin is the axis being integrated. Loop is done only on the selected bins
1864  for ( Int_t outbin = 0; outbin <= outAxis.GetNbins() + 1; ++outbin) {
1865  if (outAxis.TestBit(TAxis::kAxisRange) && ( outbin < firstOutBin || outbin > lastOutBin )) continue;
1866 
1867  // find corresponding bin number in h1 for outbin (binOut)
1868  Double_t xOut = outAxis.GetBinCenter(outbin);
1869  Int_t binOut = h1->GetXaxis()->FindBin( xOut );
1870  if (binOut <0) continue;
1871 
1872  for (Int_t inbin = firstbin ; inbin <= lastbin ; ++inbin) {
1873  Int_t binx, biny;
1874  if (onX) { binx = outbin; biny=inbin; }
1875  else { binx = inbin; biny=outbin; }
1876 
1877  if (ncuts) {
1878  if (!fPainter->IsInside(binx,biny)) continue;
1879  }
1880  Int_t bin = GetBin(binx, biny);
1881  Double_t cxy = RetrieveBinContent(bin);
1882 
1883 
1884  if (cxy) {
1885  Double_t tmp = 0;
1886  // the following fill update wrongly the fBinSumw2- need to save it before
1887  if ( useWeights ) tmp = binSumw2.fArray[binOut];
1888  h1->Fill( xOut, inAxis.GetBinCenter(inbin), cxy );
1889  if ( useWeights ) binSumw2.fArray[binOut] = tmp + fSumw2.fArray[bin];
1890  totcont += cxy;
1891  }
1892 
1893  }
1894  }
1895 
1896  // the statistics must be recalculated since by using the Fill method the total sum of weight^2 is
1897  // not computed correctly
1898  // for a profile does not much sense to re-use statistics of original TH2
1899  h1->ResetStats();
1900  // Also we need to set the entries since they have not been correctly calculated during the projection
1901  // we can only set them to the effective entries
1902  h1->SetEntries( h1->GetEffectiveEntries() );
1903 
1904 
1905  if (opt.Contains("d")) {
1906  TVirtualPad *padsav = gPad;
1907  TVirtualPad *pad = gROOT->GetSelectedPad();
1908  if (pad) pad->cd();
1909  opt.Remove(opt.First("d"),1);
1910  if (!gPad || !gPad->FindObject(h1)) {
1911  h1->Draw(opt);
1912  } else {
1913  h1->Paint(opt);
1914  }
1915  if (padsav) padsav->cd();
1916  }
1917  return h1;
1918 }
1919 
1920 
1921 ////////////////////////////////////////////////////////////////////////////////
1922 /// Project a 2-D histogram into a profile histogram along X.
1923 ///
1924 /// The projection is made from the channels along the Y axis
1925 /// ranging from firstybin to lastybin included.
1926 /// By default, bins 1 to ny are included
1927 /// When all bins are included, the number of entries in the projection
1928 /// is set to the number of entries of the 2-D histogram, otherwise
1929 /// the number of entries is incremented by 1 for all non empty cells.
1930 ///
1931 /// if option "d" is specified, the profile is drawn in the current pad.
1932 ///
1933 /// if option "o" original axis range of the target axes will be
1934 /// kept, but only bins inside the selected range will be filled.
1935 ///
1936 /// The option can also be used to specify the projected profile error type.
1937 /// Values which can be used are 's', 'i', or 'g'. See TProfile::BuildOptions for details
1938 ///
1939 /// Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
1940 /// One must create a graphical cut (mouse or C++) and specify the name
1941 /// of the cut between [] in the option.
1942 /// For example, with a TCutG named "cutg", one can call:
1943 /// myhist->ProfileX(" ",firstybin,lastybin,"[cutg]");
1944 /// To invert the cut, it is enough to put a "-" in front of its name:
1945 /// myhist->ProfileX(" ",firstybin,lastybin,"[-cutg]");
1946 /// It is possible to apply several cuts ("," means logical AND):
1947 /// myhist->ProfileX(" ",firstybin,lastybin,"[cutg1,cutg2]");
1948 ///
1949 /// NOTE that if a TProfile named "name" exists in the current directory or pad with
1950 /// a compatible axis the profile is reset and filled again with the projected contents of the TH2.
1951 /// In the case of axis incompatibility an error is reported and a NULL pointer is returned.
1952 ///
1953 /// NOTE that the X axis attributes of the TH2 are copied to the X axis of the profile.
1954 ///
1955 /// NOTE that the default under- / overflow behavior differs from what ProjectionX
1956 /// does! Profiles take the bin center into account, so here the under- and overflow
1957 /// bins are ignored by default.
1958 ///
1959 /// NOTE that the return profile histogram is computed using the Y bin center values instead of
1960 /// the real Y values which are used to fill the 2d histogram. Therefore the obtained profile is just an approximation of the
1961 /// correct profile histogram that would be obtained when filling it directly with the original data (see ROOT-7770)
1962 
1963 
1964 TProfile *TH2::ProfileX(const char *name, Int_t firstybin, Int_t lastybin, Option_t *option) const
1965 {
1966  return DoProfile(true, name, firstybin, lastybin, option);
1967 
1968 }
1969 
1970 
1971 ////////////////////////////////////////////////////////////////////////////////
1972 /// Project a 2-D histogram into a profile histogram along Y.
1973 ///
1974 /// The projection is made from the channels along the X axis
1975 /// ranging from firstxbin to lastxbin included.
1976 /// By default, bins 1 to nx are included
1977 /// When all bins are included, the number of entries in the projection
1978 /// is set to the number of entries of the 2-D histogram, otherwise
1979 /// the number of entries is incremented by 1 for all non empty cells.
1980 ///
1981 /// if option "d" is specified, the profile is drawn in the current pad.
1982 ///
1983 /// if option "o" , the original axis range of the target axis will be
1984 /// kept, but only bins inside the selected range will be filled.
1985 ///
1986 /// The option can also be used to specify the projected profile error type.
1987 /// Values which can be used are 's', 'i', or 'g'. See TProfile::BuildOptions for details
1988 /// Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
1989 ///
1990 /// One must create a graphical cut (mouse or C++) and specify the name
1991 /// of the cut between [] in the option.
1992 /// For example, with a TCutG named "cutg", one can call:
1993 /// myhist->ProfileY(" ",firstybin,lastybin,"[cutg]");
1994 /// To invert the cut, it is enough to put a "-" in front of its name:
1995 /// myhist->ProfileY(" ",firstybin,lastybin,"[-cutg]");
1996 /// It is possible to apply several cuts:
1997 /// myhist->ProfileY(" ",firstybin,lastybin,"[cutg1,cutg2]");
1998 ///
1999 /// NOTE that if a TProfile named "name" exists in the current directory or pad with
2000 /// a compatible axis the profile is reset and filled again with the projected contents of the TH2.
2001 /// In the case of axis incompatibility an error is reported and a NULL pointer is returned.
2002 ///
2003 /// NOTE that the Y axis attributes of the TH2 are copied to the X axis of the profile.
2004 ///
2005 /// NOTE that the default under- / overflow behavior differs from what ProjectionX
2006 /// does! Profiles take the bin center into account, so here the under- and overflow
2007 /// bins are ignored by default.
2008 ///
2009 /// NOTE that the return profile histogram is computed using the X bin center values instead of
2010 /// the real X values which are used to fill the 2d histogram. Therefore the obtained profile is just an approximation of the
2011 /// correct profile histogram that would be obtained when filling it directly with the original data (see ROOT-7770)
2012 
2013 
2014 TProfile *TH2::ProfileY(const char *name, Int_t firstxbin, Int_t lastxbin, Option_t *option) const
2015 {
2016  return DoProfile(false, name, firstxbin, lastxbin, option);
2017 }
2018 
2019 
2020 ////////////////////////////////////////////////////////////////////////////////
2021 /// Internal (protected) method for performing projection on the X or Y axis
2022 /// called by ProjectionX or ProjectionY
2023 
2024 TH1D *TH2::DoProjection(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
2025 {
2026  const char *expectedName = 0;
2027  Int_t inNbin;
2028  Int_t firstOutBin, lastOutBin;
2029  const TAxis* outAxis;
2030  const TAxis* inAxis;
2031 
2032  TString opt = option;
2033  TString cut;
2034  Int_t i1 = opt.Index("[");
2035  if (i1>=0) {
2036  Int_t i2 = opt.Index("]");
2037  cut = opt(i1,i2-i1+1);
2038  }
2039  opt.ToLower(); //must be called after having parsed the cut name
2040  bool originalRange = opt.Contains("o");
2041 
2042  if ( onX )
2043  {
2044  expectedName = "_px";
2045  inNbin = fYaxis.GetNbins();
2046  outAxis = GetXaxis();
2047  inAxis = GetYaxis();
2048  }
2049  else
2050  {
2051  expectedName = "_py";
2052  inNbin = fXaxis.GetNbins();
2053  outAxis = GetYaxis();
2054  inAxis = GetXaxis();
2055  }
2056 
2057  firstOutBin = outAxis->GetFirst();
2058  lastOutBin = outAxis->GetLast();
2059  if (firstOutBin == 0 && lastOutBin == 0) {
2060  firstOutBin = 1; lastOutBin = outAxis->GetNbins();
2061  }
2062 
2063  if ( lastbin < firstbin && inAxis->TestBit(TAxis::kAxisRange) ) {
2064  firstbin = inAxis->GetFirst();
2065  lastbin = inAxis->GetLast();
2066  // For special case of TAxis::SetRange, when first == 1 and last
2067  // = N and the range bit has been set, the TAxis will return 0
2068  // for both.
2069  if (firstbin == 0 && lastbin == 0)
2070  {
2071  firstbin = 1;
2072  lastbin = inAxis->GetNbins();
2073  }
2074  }
2075  if (firstbin < 0) firstbin = 0;
2076  if (lastbin < 0) lastbin = inNbin + 1;
2077  if (lastbin > inNbin+1) lastbin = inNbin + 1;
2078 
2079  // Create the projection histogram
2080  char *pname = (char*)name;
2081  if (name && strcmp(name,expectedName) == 0) {
2082  Int_t nch = strlen(GetName()) + 4;
2083  pname = new char[nch];
2084  snprintf(pname,nch,"%s%s",GetName(),name);
2085  }
2086  TH1D *h1=0;
2087  //check if histogram with identical name exist
2088  // if compatible reset and re-use previous histogram
2089  // (see https://savannah.cern.ch/bugs/?54340)
2090  TObject *h1obj = gROOT->FindObject(pname);
2091  if (h1obj && h1obj->InheritsFrom(TH1::Class())) {
2092  if (h1obj->IsA() != TH1D::Class() ) {
2093  Error("DoProjection","Histogram with name %s must be a TH1D and is a %s",name,h1obj->ClassName());
2094  return 0;
2095  }
2096  h1 = (TH1D*)h1obj;
2097  // reset the existing histogram and set always the new binning for the axis
2098  // This avoid problems when the histogram already exists and the histograms is rebinned or its range has changed
2099  // (see https://savannah.cern.ch/bugs/?94101 or https://savannah.cern.ch/bugs/?95808 )
2100  h1->Reset();
2101  const TArrayD *xbins = outAxis->GetXbins();
2102  if (xbins->fN == 0) {
2103  if ( originalRange )
2104  h1->SetBins(outAxis->GetNbins(),outAxis->GetXmin(),outAxis->GetXmax());
2105  else
2106  h1->SetBins(lastOutBin-firstOutBin+1,outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
2107  } else {
2108  // case variable bins
2109  if (originalRange )
2110  h1->SetBins(outAxis->GetNbins(),xbins->fArray);
2111  else
2112  h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);
2113  }
2114  }
2115 
2116  Int_t ncuts = 0;
2117  if (opt.Contains("[")) {
2118  ((TH2 *)this)->GetPainter();
2119  if (fPainter) ncuts = fPainter->MakeCuts((char*)cut.Data());
2120  }
2121 
2122  if (!h1) {
2123  const TArrayD *bins = outAxis->GetXbins();
2124  if (bins->fN == 0) {
2125  if ( originalRange )
2126  h1 = new TH1D(pname,GetTitle(),outAxis->GetNbins(),outAxis->GetXmin(),outAxis->GetXmax());
2127  else
2128  h1 = new TH1D(pname,GetTitle(),lastOutBin-firstOutBin+1,
2129  outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
2130  } else {
2131  // case variable bins
2132  if (originalRange )
2133  h1 = new TH1D(pname,GetTitle(),outAxis->GetNbins(),bins->fArray);
2134  else
2135  h1 = new TH1D(pname,GetTitle(),lastOutBin-firstOutBin+1,&bins->fArray[firstOutBin-1]);
2136  }
2137  if (opt.Contains("e") || GetSumw2N() ) h1->Sumw2();
2138  }
2139  if (pname != name) delete [] pname;
2140 
2141  // Copy the axis attributes and the axis labels if needed.
2142  h1->GetXaxis()->ImportAttributes(outAxis);
2143  THashList* labels=outAxis->GetLabels();
2144  if (labels) {
2145  TIter iL(labels);
2146  TObjString* lb;
2147  Int_t i = 1;
2148  while ((lb=(TObjString*)iL())) {
2149  h1->GetXaxis()->SetBinLabel(i,lb->String().Data());
2150  i++;
2151  }
2152  }
2153 
2154  h1->SetLineColor(this->GetLineColor());
2155  h1->SetFillColor(this->GetFillColor());
2156  h1->SetMarkerColor(this->GetMarkerColor());
2157  h1->SetMarkerStyle(this->GetMarkerStyle());
2158 
2159  // Fill the projected histogram
2160  Double_t cont,err2;
2161  Double_t totcont = 0;
2162  Bool_t computeErrors = h1->GetSumw2N();
2163 
2164  // implement filling of projected histogram
2165  // outbin is bin number of outAxis (the projected axis). Loop is done on all bin of TH2 histograms
2166  // inbin is the axis being integrated. Loop is done only on the selected bins
2167  for ( Int_t outbin = 0; outbin <= outAxis->GetNbins() + 1; ++outbin) {
2168  err2 = 0;
2169  cont = 0;
2170  if (outAxis->TestBit(TAxis::kAxisRange) && ( outbin < firstOutBin || outbin > lastOutBin )) continue;
2171 
2172  for (Int_t inbin = firstbin ; inbin <= lastbin ; ++inbin) {
2173  Int_t binx, biny;
2174  if (onX) { binx = outbin; biny=inbin; }
2175  else { binx = inbin; biny=outbin; }
2176 
2177  if (ncuts) {
2178  if (!fPainter->IsInside(binx,biny)) continue;
2179  }
2180  // sum bin content and error if needed
2181  cont += GetBinContent(binx,biny);
2182  if (computeErrors) {
2183  Double_t exy = GetBinError(binx,biny);
2184  err2 += exy*exy;
2185  }
2186  }
2187  // find corresponding bin number in h1 for outbin
2188  Int_t binOut = h1->GetXaxis()->FindBin( outAxis->GetBinCenter(outbin) );
2189  h1->SetBinContent(binOut ,cont);
2190  if (computeErrors) h1->SetBinError(binOut,TMath::Sqrt(err2));
2191  // sum all content
2192  totcont += cont;
2193  }
2194 
2195  // check if we can re-use the original statistics from the previous histogram
2196  bool reuseStats = false;
2197  if ( ( fgStatOverflows == false && firstbin == 1 && lastbin == inNbin ) ||
2198  ( fgStatOverflows == true && firstbin == 0 && lastbin == inNbin + 1 ) )
2199  reuseStats = true;
2200  else {
2201  // also if total content match we can re-use
2202  double eps = 1.E-12;
2203  if (IsA() == TH2F::Class() ) eps = 1.E-6;
2204  if (fTsumw != 0 && TMath::Abs( fTsumw - totcont) < TMath::Abs(fTsumw) * eps)
2205  reuseStats = true;
2206  }
2207  if (ncuts) reuseStats = false;
2208  // retrieve the statistics and set in projected histogram if we can re-use it
2209  bool reuseEntries = reuseStats;
2210  // can re-use entries if underflow/overflow are included
2211  reuseEntries &= (firstbin==0 && lastbin == inNbin+1);
2212  if (reuseStats) {
2213  Double_t stats[kNstat];
2214  GetStats(stats);
2215  if (!onX) { // case of projection on Y
2216  stats[2] = stats[4];
2217  stats[3] = stats[5];
2218  }
2219  h1->PutStats(stats);
2220  }
2221  else {
2222  // the statistics is automatically recalculated since it is reset by the call to SetBinContent
2223  // we just need to set the entries since they have not been correctly calculated during the projection
2224  // we can only set them to the effective entries
2225  h1->SetEntries( h1->GetEffectiveEntries() );
2226  }
2227  if (reuseEntries) {
2228  h1->SetEntries(fEntries);
2229  }
2230  else {
2231  // re-compute the entries
2232  // in case of error calculation (i.e. when Sumw2() is set)
2233  // use the effective entries for the entries
2234  // since this is the only way to estimate them
2235  Double_t entries = TMath::Floor( totcont + 0.5); // to avoid numerical rounding
2236  if (h1->GetSumw2N()) entries = h1->GetEffectiveEntries();
2237  h1->SetEntries( entries );
2238  }
2239 
2240  if (opt.Contains("d")) {
2241  TVirtualPad *padsav = gPad;
2242  TVirtualPad *pad = gROOT->GetSelectedPad();
2243  if (pad) pad->cd();
2244  opt.Remove(opt.First("d"),1);
2245  // remove also other options
2246  if (opt.Contains("e")) opt.Remove(opt.First("e"),1);
2247  if (!gPad || !gPad->FindObject(h1)) {
2248  h1->Draw(opt);
2249  } else {
2250  h1->Paint(opt);
2251  }
2252  if (padsav) padsav->cd();
2253  }
2254 
2255  return h1;
2256 }
2257 
2258 
2259 ////////////////////////////////////////////////////////////////////////////////
2260 /// Project a 2-D histogram into a 1-D histogram along X.
2261 ///
2262 /// The projection is always of the type TH1D.
2263 /// The projection is made from the channels along the Y axis
2264 /// ranging from firstybin to lastybin included.
2265 /// By default, all bins including under- and overflow are included.
2266 /// The number of entries in the projection is estimated from the
2267 /// number of effective entries for all the cells included in the projection.
2268 ///
2269 /// To exclude the underflow bins in Y, use firstybin=1.
2270 /// To exclude the overflow bins in Y, use lastybin=nx.
2271 ///
2272 /// if option "e" is specified, the errors are computed.
2273 /// if option "d" is specified, the projection is drawn in the current pad.
2274 /// if option "o" original axis range of the taget axes will be
2275 /// kept, but only bins inside the selected range will be filled.
2276 ///
2277 /// Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
2278 /// One must create a graphical cut (mouse or C++) and specify the name
2279 /// of the cut between [] in the option.
2280 /// For example, with a TCutG named "cutg", one can call:
2281 /// myhist->ProjectionX(" ",firstybin,lastybin,"[cutg]");
2282 /// To invert the cut, it is enough to put a "-" in front of its name:
2283 /// myhist->ProjectionX(" ",firstybin,lastybin,"[-cutg]");
2284 /// It is possible to apply several cuts:
2285 /// myhist->ProjectionX(" ",firstybin,lastybin,"[cutg1,cutg2]");
2286 ///
2287 /// NOTE that if a TH1D named "name" exists in the current directory or pad
2288 /// the histogram is reset and filled again with the projected contents of the TH2.
2289 ///
2290 /// NOTE that the X axis attributes of the TH2 are copied to the X axis of the projection.
2291 
2292 TH1D *TH2::ProjectionX(const char *name, Int_t firstybin, Int_t lastybin, Option_t *option) const
2293 {
2294  return DoProjection(true, name, firstybin, lastybin, option);
2295 }
2296 
2297 
2298 ////////////////////////////////////////////////////////////////////////////////
2299 /// Project a 2-D histogram into a 1-D histogram along Y.
2300 ///
2301 /// The projection is always of the type TH1D.
2302 /// The projection is made from the channels along the X axis
2303 /// ranging from firstxbin to lastxbin included.
2304 /// By default, all bins including under- and overflow are included.
2305 /// The number of entries in the projection is estimated from the
2306 /// number of effective entries for all the cells included in the projection
2307 ///
2308 /// To exclude the underflow bins in X, use firstxbin=1.
2309 /// To exclude the oveerflow bins in X, use lastxbin=nx.
2310 ///
2311 /// if option "e" is specified, the errors are computed.
2312 /// if option "d" is specified, the projection is drawn in the current pad.
2313 /// if option "o" original axis range of the taget axes will be
2314 /// kept, but only bins inside the selected range will be filled.
2315 ///
2316 /// Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
2317 /// One must create a graphical cut (mouse or C++) and specify the name
2318 /// of the cut between [] in the option.
2319 /// For example, with a TCutG named "cutg", one can call:
2320 /// myhist->ProjectionY(" ",firstxbin,lastxbin,"[cutg]");
2321 /// To invert the cut, it is enough to put a "-" in front of its name:
2322 /// myhist->ProjectionY(" ",firstxbin,lastxbin,"[-cutg]");
2323 /// It is possible to apply several cuts:
2324 /// myhist->ProjectionY(" ",firstxbin,lastxbin,"[cutg1,cutg2]");
2325 ///
2326 /// NOTE that if a TH1D named "name" exists in the current directory or pad and having
2327 /// a compatible axis, the histogram is reset and filled again with the projected contents of the TH2.
2328 /// In the case of axis incompatibility, an error is reported and a NULL pointer is returned.
2329 ///
2330 /// NOTE that the Y axis attributes of the TH2 are copied to the X axis of the projection.
2331 
2332 TH1D *TH2::ProjectionY(const char *name, Int_t firstxbin, Int_t lastxbin, Option_t *option) const
2333 {
2334  return DoProjection(false, name, firstxbin, lastxbin, option);
2335 }
2336 
2337 
2338 ////////////////////////////////////////////////////////////////////////////////
2339 /// Replace current statistics with the values in array stats
2340 
2342 {
2343  TH1::PutStats(stats);
2344  fTsumwy = stats[4];
2345  fTsumwy2 = stats[5];
2346  fTsumwxy = stats[6];
2347 }
2348 
2349 
2350 ////////////////////////////////////////////////////////////////////////////////
2351 /// Compute the X distribution of quantiles in the other variable Y
2352 /// name is the name of the returned histogram
2353 /// prob is the probability content for the quantile (0.5 is the default for the median)
2354 /// An approximate error for the quantile is computed assuming that the distribution in
2355 /// the other variable is normal. According to this approximate formula the error on the quantile is
2356 /// estimated as sqrt( p (1-p) / ( n * f(q)^2) ), where p is the probability content of the quantile and
2357 /// n is the number of events used to compute the quantile and f(q) is the probability distribution for the
2358 /// other variable evaluated at the obtained quantile. In the error estimation the probability is then assumed to be
2359 /// a normal distribution.
2360 
2361 TH1D* TH2::QuantilesX( Double_t prob, const char * name) const
2362 {
2363  return DoQuantiles(true, name, prob);
2364 }
2365 
2366 
2367 ////////////////////////////////////////////////////////////////////////////////
2368 /// Compute the Y distribution of quantiles in the other variable X
2369 /// name is the name of the returned histogram
2370 /// prob is the probability content for the quantile (0.5 is the default for the median)
2371 /// An approximate error for the quantile is computed assuming that the distribution in
2372 /// the other variable is normal.
2373 
2374 TH1D* TH2::QuantilesY( Double_t prob, const char * name) const
2375 {
2376  return DoQuantiles(false, name, prob);
2377 }
2378 
2379 
2380 ////////////////////////////////////////////////////////////////////////////////
2381 /// Implementation of quantiles for x or y
2382 
2383 TH1D* TH2::DoQuantiles(bool onX, const char * name, Double_t prob) const
2384 {
2385  const TAxis *outAxis = 0;
2386  const TAxis *inAxis = 0;
2387  if ( onX ) {
2388  outAxis = GetXaxis();
2389  inAxis = GetYaxis();
2390  } else {
2391  outAxis = GetYaxis();
2392  inAxis = GetXaxis();
2393  }
2394 
2395  // build first name of returned histogram
2396  TString qname = name;
2397  if (qname.IsNull() || qname == "_qx" || qname == "_qy") {
2398  const char * qtype = (onX) ? "qx" : "qy";
2399  qname = TString::Format("%s_%s_%3.2f",GetName(),qtype, prob);
2400  }
2401  // check if the histogram is already existing
2402  TH1D *h1=0;
2403  //check if histogram with identical name exist
2404  TObject *h1obj = gROOT->FindObject(qname);
2405  if (h1obj) {
2406  h1 = dynamic_cast<TH1D*>(h1obj);
2407  if (!h1) {
2408  Error("DoQuantiles","Histogram with name %s must be a TH1D and is a %s",qname.Data(),h1obj->ClassName());
2409  return 0;
2410  }
2411  }
2412  if (h1) {
2413  h1->Reset();
2414  } else {
2415  // create the histogram
2416  h1 = new TH1D(qname, GetTitle(), 1, 0, 1);
2417  }
2418  // set the bin content
2419  Int_t firstOutBin = outAxis->GetFirst();
2420  Int_t lastOutBin = outAxis->GetLast();
2421  const TArrayD *xbins = outAxis->GetXbins();
2422  if (xbins->fN == 0)
2423  h1->SetBins(lastOutBin-firstOutBin+1,outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
2424  else
2425  h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);
2426 
2427  // set the bin content of the histogram
2428  Double_t pp[1];
2429  pp[0] = prob;
2430 
2431  TH1D * slice = 0;
2432  for (int ibin = inAxis->GetFirst() ; ibin <= inAxis->GetLast() ; ++ibin) {
2433  Double_t qq[1];
2434  // do a projection on the opposite axis
2435  slice = DoProjection(!onX, "tmp",ibin,ibin,"");
2436  if (!slice) break;
2437  if (slice->GetSum() == 0) continue;
2438  slice->GetQuantiles(1,qq,pp);
2439  h1->SetBinContent(ibin,qq[0]);
2440  // compute error using normal approximation
2441  // quantile error ~ sqrt (q*(1-q)/ *( n * f(xq)^2 ) from Kendall
2442  // where f(xq) is the p.d.f value at the quantile xq
2443  Double_t n = slice->GetEffectiveEntries();
2444  Double_t f = TMath::Gaus(qq[0], slice->GetMean(), slice->GetStdDev(), kTRUE);
2445  Double_t error = 0;
2446  // set the errors to zero in case of small statistics
2447  if (f > 0 && n > 1)
2448  error = TMath::Sqrt( prob*(1.-prob)/ (n * f * f) );
2449  h1->SetBinError(ibin, error);
2450  }
2451  if (slice) delete slice;
2452  return h1;
2453 }
2454 
2455 
2456 ////////////////////////////////////////////////////////////////////////////////
2457 /// Reset this histogram: contents, errors, etc.
2458 
2459 void TH2::Reset(Option_t *option)
2460 {
2461  TH1::Reset(option);
2462  TString opt = option;
2463  opt.ToUpper();
2464 
2465  if (opt.Contains("ICE") && !opt.Contains("S")) return;
2466  fTsumwy = 0;
2467  fTsumwy2 = 0;
2468  fTsumwxy = 0;
2469 }
2470 
2471 
2472 ////////////////////////////////////////////////////////////////////////////////
2473 /// Set bin content
2474 
2476 {
2477  fEntries++;
2478  fTsumw = 0;
2479  if (bin < 0) return;
2480  if (bin >= fNcells) return;
2481  UpdateBinContent(bin, content);
2482 }
2483 
2484 
2485 ////////////////////////////////////////////////////////////////////////////////
2486 /// When the mouse is moved in a pad containing a 2-d view of this histogram
2487 /// a second canvas shows the projection along X corresponding to the
2488 /// mouse position along Y.
2489 /// To stop the generation of the projections, delete the canvas
2490 /// containing the projection.
2491 
2493 {
2494  GetPainter();
2495 
2496  if (fPainter) fPainter->SetShowProjection("x",nbins);
2497 }
2498 
2499 
2500 ////////////////////////////////////////////////////////////////////////////////
2501 /// When the mouse is moved in a pad containing a 2-d view of this histogram
2502 /// a second canvas shows the projection along Y corresponding to the
2503 /// mouse position along X.
2504 /// To stop the generation of the projections, delete the canvas
2505 /// containing the projection.
2506 
2508 {
2509  GetPainter();
2510 
2511  if (fPainter) fPainter->SetShowProjection("y",nbins);
2512 }
2513 
2514 
2515 ////////////////////////////////////////////////////////////////////////////////
2516 /// This function calculates the background spectrum in this histogram.
2517 /// The background is returned as a histogram.
2518 /// to be implemented (may be)
2519 
2521 {
2522 
2523  return (TH1*)gROOT->ProcessLineFast(Form("TSpectrum2::StaticBackground((TH1*)0x%lx,%d,\"%s\")",
2524  (ULong_t)this, niter, option));
2525 }
2526 
2527 
2528 ////////////////////////////////////////////////////////////////////////////////
2529 ///Interface to TSpectrum2::Search
2530 ///the function finds peaks in this histogram where the width is > sigma
2531 ///and the peak maximum greater than threshold*maximum bin content of this.
2532 ///for more detauils see TSpectrum::Search.
2533 ///note the difference in the default value for option compared to TSpectrum2::Search
2534 ///option="" by default (instead of "goff")
2535 
2537 {
2538 
2539  return (Int_t)gROOT->ProcessLineFast(Form("TSpectrum2::StaticSearch((TH1*)0x%lx,%g,\"%s\",%g)",
2540  (ULong_t)this, sigma, option, threshold));
2541 }
2542 
2543 
2544 ////////////////////////////////////////////////////////////////////////////////
2545 /// Smooth bin contents of this 2-d histogram using kernel algorithms
2546 /// similar to the ones used in the raster graphics community.
2547 /// Bin contents in the active range are replaced by their smooth values.
2548 /// If Errors are defined via Sumw2, they are also scaled and computed.
2549 /// However, note the resulting errors will be correlated between different-bins, so
2550 /// the errors should not be used blindly to perform any calculation involving several bins,
2551 /// like fitting the histogram. One would need to compute also the bin by bin correlation matrix.
2552 ///
2553 /// 3 kernels are proposed k5a, k5b and k3a.
2554 /// k5a and k5b act on 5x5 cells (i-2,i-1,i,i+1,i+2, and same for j)
2555 /// k5b is a bit more stronger in smoothing
2556 /// k3a acts only on 3x3 cells (i-1,i,i+1, and same for j).
2557 /// By default the kernel "k5a" is used. You can select the kernels "k5b" or "k3a"
2558 /// via the option argument.
2559 /// If TAxis::SetRange has been called on the x or/and y axis, only the bins
2560 /// in the specified range are smoothed.
2561 /// In the current implementation if the first argument is not used (default value=1).
2562 ///
2563 /// implementation by David McKee (dmckee@bama.ua.edu). Extended by Rene Brun
2564 
2565 void TH2::Smooth(Int_t ntimes, Option_t *option)
2566 {
2567  Double_t k5a[5][5] = { { 0, 0, 1, 0, 0 },
2568  { 0, 2, 2, 2, 0 },
2569  { 1, 2, 5, 2, 1 },
2570  { 0, 2, 2, 2, 0 },
2571  { 0, 0, 1, 0, 0 } };
2572  Double_t k5b[5][5] = { { 0, 1, 2, 1, 0 },
2573  { 1, 2, 4, 2, 1 },
2574  { 2, 4, 8, 4, 2 },
2575  { 1, 2, 4, 2, 1 },
2576  { 0, 1, 2, 1, 0 } };
2577  Double_t k3a[3][3] = { { 0, 1, 0 },
2578  { 1, 2, 1 },
2579  { 0, 1, 0 } };
2580 
2581  if (ntimes > 1) {
2582  Warning("Smooth","Currently only ntimes=1 is supported");
2583  }
2584  TString opt = option;
2585  opt.ToLower();
2586  Int_t ksize_x=5;
2587  Int_t ksize_y=5;
2588  Double_t *kernel = &k5a[0][0];
2589  if (opt.Contains("k5b")) kernel = &k5b[0][0];
2590  if (opt.Contains("k3a")) {
2591  kernel = &k3a[0][0];
2592  ksize_x=3;
2593  ksize_y=3;
2594  }
2595 
2596  // find i,j ranges
2597  Int_t ifirst = fXaxis.GetFirst();
2598  Int_t ilast = fXaxis.GetLast();
2599  Int_t jfirst = fYaxis.GetFirst();
2600  Int_t jlast = fYaxis.GetLast();
2601 
2602  // Determine the size of the bin buffer(s) needed
2604  Int_t nx = GetNbinsX();
2605  Int_t ny = GetNbinsY();
2606  Int_t bufSize = (nx+2)*(ny+2);
2607  Double_t *buf = new Double_t[bufSize];
2608  Double_t *ebuf = 0;
2609  if (fSumw2.fN) ebuf = new Double_t[bufSize];
2610 
2611  // Copy all the data to the temporary buffers
2612  Int_t i,j,bin;
2613  for (i=ifirst; i<=ilast; i++){
2614  for (j=jfirst; j<=jlast; j++){
2615  bin = GetBin(i,j);
2616  buf[bin] = RetrieveBinContent(bin);
2617  if (ebuf) ebuf[bin]=GetBinError(bin);
2618  }
2619  }
2620 
2621  // Kernel tail sizes (kernel sizes must be odd for this to work!)
2622  Int_t x_push = (ksize_x-1)/2;
2623  Int_t y_push = (ksize_y-1)/2;
2624 
2625  // main work loop
2626  for (i=ifirst; i<=ilast; i++){
2627  for (j=jfirst; j<=jlast; j++) {
2628  Double_t content = 0.0;
2629  Double_t error = 0.0;
2630  Double_t norm = 0.0;
2631 
2632  for (Int_t n=0; n<ksize_x; n++) {
2633  for (Int_t m=0; m<ksize_y; m++) {
2634  Int_t xb = i+(n-x_push);
2635  Int_t yb = j+(m-y_push);
2636  if ( (xb >= 1) && (xb <= nx) && (yb >= 1) && (yb <= ny) ) {
2637  bin = GetBin(xb,yb);
2638  Double_t k = kernel[n*ksize_y +m];
2639  //if ( (k != 0.0 ) && (buf[bin] != 0.0) ) { // General version probably does not want the second condition
2640  if ( k != 0.0 ) {
2641  norm += k;
2642  content += k*buf[bin];
2643  if (ebuf) error += k*k*ebuf[bin]*ebuf[bin];
2644  }
2645  }
2646  }
2647  }
2648 
2649  if ( norm != 0.0 ) {
2650  SetBinContent(i,j,content/norm);
2651  if (ebuf) {
2652  error /= (norm*norm);
2653  SetBinError(i,j,sqrt(error));
2654  }
2655  }
2656  }
2657  }
2658  fEntries = nentries;
2659 
2660  delete [] buf;
2661  delete [] ebuf;
2662 }
2663 
2664 
2665 ////////////////////////////////////////////////////////////////////////////////
2666 /// Stream an object of class TH2.
2667 
2668 void TH2::Streamer(TBuffer &R__b)
2669 {
2670  if (R__b.IsReading()) {
2671  UInt_t R__s, R__c;
2672  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
2673  if (R__v > 2) {
2674  R__b.ReadClassBuffer(TH2::Class(), this, R__v, R__s, R__c);
2675  return;
2676  }
2677  //====process old versions before automatic schema evolution
2678  TH1::Streamer(R__b);
2679  R__b >> fScalefactor;
2680  R__b >> fTsumwy;
2681  R__b >> fTsumwy2;
2682  R__b >> fTsumwxy;
2683  //====end of old versions
2684 
2685  } else {
2686  R__b.WriteClassBuffer(TH2::Class(),this);
2687  }
2688 }
2689 
2690 
2691 //______________________________________________________________________________
2692 // TH2C methods
2693 // TH2C a 2-D histogram with one byte per cell (char)
2694 //______________________________________________________________________________
2695 
2696 ClassImp(TH2C)
2697 
2698 
2699 ////////////////////////////////////////////////////////////////////////////////
2700 /// Constructor.
2701 
2703 {
2704  SetBinsLength(9);
2705  if (fgDefaultSumw2) Sumw2();
2706 }
2707 
2708 
2709 ////////////////////////////////////////////////////////////////////////////////
2710 /// Destructor.
2711 
2713 {
2714 }
2715 
2716 
2717 ////////////////////////////////////////////////////////////////////////////////
2718 /// Constructor.
2719 
2720 TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
2721  ,Int_t nbinsy,Double_t ylow,Double_t yup)
2722  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
2723 {
2725  if (fgDefaultSumw2) Sumw2();
2726 
2727  if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
2728 }
2729 
2730 
2731 ////////////////////////////////////////////////////////////////////////////////
2732 /// Constructor.
2733 
2734 TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
2735  ,Int_t nbinsy,Double_t ylow,Double_t yup)
2736  :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
2737 {
2739  if (fgDefaultSumw2) Sumw2();
2740 }
2741 
2742 
2743 ////////////////////////////////////////////////////////////////////////////////
2744 /// Constructor.
2745 
2746 TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
2747  ,Int_t nbinsy,const Double_t *ybins)
2748  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
2749 {
2751  if (fgDefaultSumw2) Sumw2();
2752 }
2753 
2754 
2755 ////////////////////////////////////////////////////////////////////////////////
2756 /// Constructor.
2757 
2758 TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
2759  ,Int_t nbinsy,const Double_t *ybins)
2760  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
2761 {
2763  if (fgDefaultSumw2) Sumw2();
2764 }
2765 
2766 
2767 ////////////////////////////////////////////////////////////////////////////////
2768 /// Constructor.
2769 
2770 TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
2771  ,Int_t nbinsy,const Float_t *ybins)
2772  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
2773 {
2775  if (fgDefaultSumw2) Sumw2();
2776 }
2777 
2778 
2779 ////////////////////////////////////////////////////////////////////////////////
2780 /// Copy constructor.
2781 
2782 TH2C::TH2C(const TH2C &h2c) : TH2(), TArrayC()
2783 {
2784  ((TH2C&)h2c).Copy(*this);
2785 }
2786 
2787 
2788 ////////////////////////////////////////////////////////////////////////////////
2789 /// Increment bin content by 1.
2790 
2792 {
2793  if (fArray[bin] < 127) fArray[bin]++;
2794 }
2795 
2796 
2797 ////////////////////////////////////////////////////////////////////////////////
2798 /// Increment bin content by w.
2799 
2801 {
2802  Int_t newval = fArray[bin] + Int_t(w);
2803  if (newval > -128 && newval < 128) {fArray[bin] = Char_t(newval); return;}
2804  if (newval < -127) fArray[bin] = -127;
2805  if (newval > 127) fArray[bin] = 127;
2806 }
2807 
2808 
2809 ////////////////////////////////////////////////////////////////////////////////
2810 /// Copy.
2811 
2812 void TH2C::Copy(TObject &newth2) const
2813 {
2814  TH2::Copy((TH2C&)newth2);
2815 }
2816 
2817 
2818 ////////////////////////////////////////////////////////////////////////////////
2819 /// Reset this histogram: contents, errors, etc.
2820 
2821 void TH2C::Reset(Option_t *option)
2822 {
2823  TH2::Reset(option);
2824  TArrayC::Reset();
2825 }
2826 
2827 
2828 ////////////////////////////////////////////////////////////////////////////////
2829 /// Set total number of bins including under/overflow
2830 /// Reallocate bin contents array
2831 
2833 {
2834  if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
2835  fNcells = n;
2836  TArrayC::Set(n);
2837 }
2838 
2839 
2840 ////////////////////////////////////////////////////////////////////////////////
2841 /// Stream an object of class TH2C.
2842 
2843 void TH2C::Streamer(TBuffer &R__b)
2844 {
2845  if (R__b.IsReading()) {
2846  UInt_t R__s, R__c;
2847  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
2848  if (R__v > 2) {
2849  R__b.ReadClassBuffer(TH2C::Class(), this, R__v, R__s, R__c);
2850  return;
2851  }
2852  //====process old versions before automatic schema evolution
2853  if (R__v < 2) {
2854  R__b.ReadVersion();
2855  TH1::Streamer(R__b);
2856  TArrayC::Streamer(R__b);
2857  R__b.ReadVersion();
2858  R__b >> fScalefactor;
2859  R__b >> fTsumwy;
2860  R__b >> fTsumwy2;
2861  R__b >> fTsumwxy;
2862  } else {
2863  TH2::Streamer(R__b);
2864  TArrayC::Streamer(R__b);
2865  R__b.CheckByteCount(R__s, R__c, TH2C::IsA());
2866  }
2867  //====end of old versions
2868 
2869  } else {
2870  R__b.WriteClassBuffer(TH2C::Class(),this);
2871  }
2872 }
2873 
2874 
2875 ////////////////////////////////////////////////////////////////////////////////
2876 /// Operator =
2877 
2879 {
2880  if (this != &h1) ((TH2C&)h1).Copy(*this);
2881  return *this;
2882 }
2883 
2884 
2885 ////////////////////////////////////////////////////////////////////////////////
2886 /// Operator *
2887 
2889 {
2890  TH2C hnew = h1;
2891  hnew.Scale(c1);
2892  hnew.SetDirectory(0);
2893  return hnew;
2894 }
2895 
2896 
2897 ////////////////////////////////////////////////////////////////////////////////
2898 /// Operator +
2899 
2901 {
2902  TH2C hnew = h1;
2903  hnew.Add(&h2,1);
2904  hnew.SetDirectory(0);
2905  return hnew;
2906 }
2907 
2908 
2909 ////////////////////////////////////////////////////////////////////////////////
2910 /// Operator -
2911 
2913 {
2914  TH2C hnew = h1;
2915  hnew.Add(&h2,-1);
2916  hnew.SetDirectory(0);
2917  return hnew;
2918 }
2919 
2920 
2921 ////////////////////////////////////////////////////////////////////////////////
2922 /// Operator *
2923 
2925 {
2926  TH2C hnew = h1;
2927  hnew.Multiply(&h2);
2928  hnew.SetDirectory(0);
2929  return hnew;
2930 }
2931 
2932 
2933 ////////////////////////////////////////////////////////////////////////////////
2934 /// Operator /
2935 
2937 {
2938  TH2C hnew = h1;
2939  hnew.Divide(&h2);
2940  hnew.SetDirectory(0);
2941  return hnew;
2942 }
2943 
2944 
2945 //______________________________________________________________________________
2946 // TH2S methods
2947 // TH2S a 2-D histogram with two bytes per cell (short integer)
2948 //______________________________________________________________________________
2949 
2950 ClassImp(TH2S)
2951 
2952 
2953 ////////////////////////////////////////////////////////////////////////////////
2954 /// Constructor.
2955 
2957 {
2958  SetBinsLength(9);
2959  if (fgDefaultSumw2) Sumw2();
2960 }
2961 
2962 
2963 ////////////////////////////////////////////////////////////////////////////////
2964 /// Destructor.
2965 
2967 {
2968 }
2969 
2970 
2971 ////////////////////////////////////////////////////////////////////////////////
2972 /// Constructor.
2973 
2974 TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
2975  ,Int_t nbinsy,Double_t ylow,Double_t yup)
2976  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
2977 {
2979  if (fgDefaultSumw2) Sumw2();
2980 
2981  if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
2982 }
2983 
2984 
2985 ////////////////////////////////////////////////////////////////////////////////
2986 /// Constructor.
2987 
2988 TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
2989  ,Int_t nbinsy,Double_t ylow,Double_t yup)
2990  :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
2991 {
2993  if (fgDefaultSumw2) Sumw2();
2994 }
2995 
2996 
2997 ////////////////////////////////////////////////////////////////////////////////
2998 /// Constructor.
2999 
3000 TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3001  ,Int_t nbinsy,const Double_t *ybins)
3002  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
3003 {
3005  if (fgDefaultSumw2) Sumw2();
3006 }
3007 
3008 
3009 ////////////////////////////////////////////////////////////////////////////////
3010 /// Constructor.
3011 
3012 TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3013  ,Int_t nbinsy,const Double_t *ybins)
3014  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3015 {
3017  if (fgDefaultSumw2) Sumw2();
3018 }
3019 
3020 
3021 ////////////////////////////////////////////////////////////////////////////////
3022 /// Constructor.
3023 
3024 TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
3025  ,Int_t nbinsy,const Float_t *ybins)
3026  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3027 {
3029  if (fgDefaultSumw2) Sumw2();
3030 }
3031 
3032 
3033 ////////////////////////////////////////////////////////////////////////////////
3034 /// Copy constructor.
3035 
3036 TH2S::TH2S(const TH2S &h2s) : TH2(), TArrayS()
3037 {
3038  ((TH2S&)h2s).Copy(*this);
3039 }
3040 
3041 
3042 ////////////////////////////////////////////////////////////////////////////////
3043 /// Increment bin content by 1.
3044 
3046 {
3047  if (fArray[bin] < 32767) fArray[bin]++;
3048 }
3049 
3050 
3051 ////////////////////////////////////////////////////////////////////////////////
3052 /// Increment bin content by w.
3053 
3055 {
3056  Int_t newval = fArray[bin] + Int_t(w);
3057  if (newval > -32768 && newval < 32768) {fArray[bin] = Short_t(newval); return;}
3058  if (newval < -32767) fArray[bin] = -32767;
3059  if (newval > 32767) fArray[bin] = 32767;
3060 }
3061 
3062 
3063 ////////////////////////////////////////////////////////////////////////////////
3064 /// Copy.
3065 
3066 void TH2S::Copy(TObject &newth2) const
3067 {
3068  TH2::Copy((TH2S&)newth2);
3069 }
3070 
3071 
3072 ////////////////////////////////////////////////////////////////////////////////
3073 /// Reset this histogram: contents, errors, etc.
3074 
3075 void TH2S::Reset(Option_t *option)
3076 {
3077  TH2::Reset(option);
3078  TArrayS::Reset();
3079 }
3080 
3081 
3082 ////////////////////////////////////////////////////////////////////////////////
3083 /// Set total number of bins including under/overflow
3084 /// Reallocate bin contents array
3085 
3087 {
3088  if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
3089  fNcells = n;
3090  TArrayS::Set(n);
3091 }
3092 
3093 
3094 ////////////////////////////////////////////////////////////////////////////////
3095 /// Stream an object of class TH2S.
3096 
3097 void TH2S::Streamer(TBuffer &R__b)
3098 {
3099  if (R__b.IsReading()) {
3100  UInt_t R__s, R__c;
3101  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
3102  if (R__v > 2) {
3103  R__b.ReadClassBuffer(TH2S::Class(), this, R__v, R__s, R__c);
3104  return;
3105  }
3106  //====process old versions before automatic schema evolution
3107  if (R__v < 2) {
3108  R__b.ReadVersion();
3109  TH1::Streamer(R__b);
3110  TArrayS::Streamer(R__b);
3111  R__b.ReadVersion();
3112  R__b >> fScalefactor;
3113  R__b >> fTsumwy;
3114  R__b >> fTsumwy2;
3115  R__b >> fTsumwxy;
3116  } else {
3117  TH2::Streamer(R__b);
3118  TArrayS::Streamer(R__b);
3119  R__b.CheckByteCount(R__s, R__c, TH2S::IsA());
3120  }
3121  //====end of old versions
3122 
3123  } else {
3124  R__b.WriteClassBuffer(TH2S::Class(),this);
3125  }
3126 }
3127 
3128 
3129 ////////////////////////////////////////////////////////////////////////////////
3130 /// Operator =
3131 
3133 {
3134  if (this != &h1) ((TH2S&)h1).Copy(*this);
3135  return *this;
3136 }
3137 
3138 
3139 ////////////////////////////////////////////////////////////////////////////////
3140 /// Operator *
3141 
3143 {
3144  TH2S hnew = h1;
3145  hnew.Scale(c1);
3146  hnew.SetDirectory(0);
3147  return hnew;
3148 }
3149 
3150 
3151 ////////////////////////////////////////////////////////////////////////////////
3152 /// Operator +
3153 
3155 {
3156  TH2S hnew = h1;
3157  hnew.Add(&h2,1);
3158  hnew.SetDirectory(0);
3159  return hnew;
3160 }
3161 
3162 
3163 ////////////////////////////////////////////////////////////////////////////////
3164 /// Operator -
3165 
3167 {
3168  TH2S hnew = h1;
3169  hnew.Add(&h2,-1);
3170  hnew.SetDirectory(0);
3171  return hnew;
3172 }
3173 
3174 
3175 ////////////////////////////////////////////////////////////////////////////////
3176 /// Operator *
3177 
3179 {
3180  TH2S hnew = h1;
3181  hnew.Multiply(&h2);
3182  hnew.SetDirectory(0);
3183  return hnew;
3184 }
3185 
3186 
3187 ////////////////////////////////////////////////////////////////////////////////
3188 /// Operator /
3189 
3191 {
3192  TH2S hnew = h1;
3193  hnew.Divide(&h2);
3194  hnew.SetDirectory(0);
3195  return hnew;
3196 }
3197 
3198 
3199 //______________________________________________________________________________
3200 // TH2I methods
3201 // TH2I a 2-D histogram with four bytes per cell (32 bits integer)
3202 //______________________________________________________________________________
3203 
3204 ClassImp(TH2I)
3205 
3206 
3207 ////////////////////////////////////////////////////////////////////////////////
3208 /// Constructor.
3209 
3211 {
3212  SetBinsLength(9);
3213  if (fgDefaultSumw2) Sumw2();
3214 }
3215 
3216 
3217 ////////////////////////////////////////////////////////////////////////////////
3218 /// Destructor.
3219 
3221 {
3222 }
3223 
3224 
3225 ////////////////////////////////////////////////////////////////////////////////
3226 /// Constructor.
3227 
3228 TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3229  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3230  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
3231 {
3233  if (fgDefaultSumw2) Sumw2();
3234 
3235  if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
3236 }
3237 
3238 
3239 ////////////////////////////////////////////////////////////////////////////////
3240 /// Constructor.
3241 
3242 TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3243  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3244  :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
3245 {
3247  if (fgDefaultSumw2) Sumw2();
3248 }
3249 
3250 
3251 ////////////////////////////////////////////////////////////////////////////////
3252 /// Constructor.
3253 
3254 TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3255  ,Int_t nbinsy,const Double_t *ybins)
3256  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
3257 {
3259  if (fgDefaultSumw2) Sumw2();
3260 }
3261 
3262 
3263 ////////////////////////////////////////////////////////////////////////////////
3264 /// Constructor.
3265 
3266 TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3267  ,Int_t nbinsy,const Double_t *ybins)
3268  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3269 {
3271  if (fgDefaultSumw2) Sumw2();
3272 }
3273 
3274 
3275 ////////////////////////////////////////////////////////////////////////////////
3276 /// Constructor.
3277 
3278 TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
3279  ,Int_t nbinsy,const Float_t *ybins)
3280  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3281 {
3283  if (fgDefaultSumw2) Sumw2();
3284 }
3285 
3286 
3287 ////////////////////////////////////////////////////////////////////////////////
3288 /// Copy constructor.
3289 
3290 TH2I::TH2I(const TH2I &h2i) : TH2(), TArrayI()
3291 {
3292  ((TH2I&)h2i).Copy(*this);
3293 }
3294 
3295 
3296 ////////////////////////////////////////////////////////////////////////////////
3297 /// Increment bin content by 1.
3298 
3300 {
3301  if (fArray[bin] < 2147483647) fArray[bin]++;
3302 }
3303 
3304 
3305 ////////////////////////////////////////////////////////////////////////////////
3306 /// Increment bin content by w.
3307 
3309 {
3310  Int_t newval = fArray[bin] + Int_t(w);
3311  if (newval > -2147483647 && newval < 2147483647) {fArray[bin] = Int_t(newval); return;}
3312  if (newval < -2147483647) fArray[bin] = -2147483647;
3313  if (newval > 2147483647) fArray[bin] = 2147483647;
3314 }
3315 
3316 
3317 ////////////////////////////////////////////////////////////////////////////////
3318 /// Copy.
3319 
3320 void TH2I::Copy(TObject &newth2) const
3321 {
3322  TH2::Copy((TH2I&)newth2);
3323 }
3324 
3325 
3326 ////////////////////////////////////////////////////////////////////////////////
3327 /// Reset this histogram: contents, errors, etc.
3328 
3329 void TH2I::Reset(Option_t *option)
3330 {
3331  TH2::Reset(option);
3332  TArrayI::Reset();
3333 }
3334 
3335 
3336 ////////////////////////////////////////////////////////////////////////////////
3337 /// Set total number of bins including under/overflow
3338 /// Reallocate bin contents array
3339 
3341 {
3342  if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
3343  fNcells = n;
3344  TArrayI::Set(n);
3345 }
3346 
3347 
3348 ////////////////////////////////////////////////////////////////////////////////
3349 /// Operator =
3350 
3352 {
3353  if (this != &h1) ((TH2I&)h1).Copy(*this);
3354  return *this;
3355 }
3356 
3357 
3358 ////////////////////////////////////////////////////////////////////////////////
3359 /// Operator *
3360 
3362 {
3363  TH2I hnew = h1;
3364  hnew.Scale(c1);
3365  hnew.SetDirectory(0);
3366  return hnew;
3367 }
3368 
3369 
3370 ////////////////////////////////////////////////////////////////////////////////
3371 /// Operator +
3372 
3374 {
3375  TH2I hnew = h1;
3376  hnew.Add(&h2,1);
3377  hnew.SetDirectory(0);
3378  return hnew;
3379 }
3380 
3381 
3382 ////////////////////////////////////////////////////////////////////////////////
3383 /// Operator -
3384 
3386 {
3387  TH2I hnew = h1;
3388  hnew.Add(&h2,-1);
3389  hnew.SetDirectory(0);
3390  return hnew;
3391 }
3392 
3393 
3394 ////////////////////////////////////////////////////////////////////////////////
3395 /// Operator *
3396 
3398 {
3399  TH2I hnew = h1;
3400  hnew.Multiply(&h2);
3401  hnew.SetDirectory(0);
3402  return hnew;
3403 }
3404 
3405 
3406 ////////////////////////////////////////////////////////////////////////////////
3407 /// Operator /
3408 
3410 {
3411  TH2I hnew = h1;
3412  hnew.Divide(&h2);
3413  hnew.SetDirectory(0);
3414  return hnew;
3415 }
3416 
3417 
3418 //______________________________________________________________________________
3419 // TH2F methods
3420 // TH2F a 2-D histogram with four bytes per cell (float)
3421 //______________________________________________________________________________
3422 
3423 ClassImp(TH2F)
3424 
3425 
3426 ////////////////////////////////////////////////////////////////////////////////
3427 /// Constructor.
3428 
3430 {
3431  SetBinsLength(9);
3432  if (fgDefaultSumw2) Sumw2();
3433 }
3434 
3435 
3436 ////////////////////////////////////////////////////////////////////////////////
3437 /// Destructor.
3438 
3440 {
3441 }
3442 
3443 
3444 ////////////////////////////////////////////////////////////////////////////////
3445 /// Constructor.
3446 
3447 TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3448  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3449  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
3450 {
3452  if (fgDefaultSumw2) Sumw2();
3453 
3454  if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
3455 }
3456 
3457 
3458 ////////////////////////////////////////////////////////////////////////////////
3459 /// Constructor.
3460 
3461 TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3462  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3463  :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
3464 {
3466  if (fgDefaultSumw2) Sumw2();
3467 }
3468 
3469 
3470 ////////////////////////////////////////////////////////////////////////////////
3471 /// Constructor.
3472 
3473 TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3474  ,Int_t nbinsy,const Double_t *ybins)
3475  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
3476 {
3478  if (fgDefaultSumw2) Sumw2();
3479 }
3480 
3481 
3482 ////////////////////////////////////////////////////////////////////////////////
3483 /// Constructor.
3484 
3485 TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3486  ,Int_t nbinsy,const Double_t *ybins)
3487  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3488 {
3490  if (fgDefaultSumw2) Sumw2();
3491 }
3492 
3493 
3494 ////////////////////////////////////////////////////////////////////////////////
3495 /// Constructor.
3496 
3497 TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
3498  ,Int_t nbinsy,const Float_t *ybins)
3499  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3500 {
3502  if (fgDefaultSumw2) Sumw2();
3503 }
3504 
3505 
3506 ////////////////////////////////////////////////////////////////////////////////
3507 /// Constructor.
3508 
3510 :TH2("TMatrixFBase","",m.GetNcols(),m.GetColLwb(),1+m.GetColUpb(),m.GetNrows(),m.GetRowLwb(),1+m.GetRowUpb())
3511 {
3513  Int_t ilow = m.GetRowLwb();
3514  Int_t iup = m.GetRowUpb();
3515  Int_t jlow = m.GetColLwb();
3516  Int_t jup = m.GetColUpb();
3517  for (Int_t i=ilow;i<=iup;i++) {
3518  for (Int_t j=jlow;j<=jup;j++) {
3519  SetBinContent(j-jlow+1,i-ilow+1,m(i,j));
3520  }
3521  }
3522 }
3523 
3524 
3525 ////////////////////////////////////////////////////////////////////////////////
3526 /// Copy constructor.
3527 
3528 TH2F::TH2F(const TH2F &h2f) : TH2(), TArrayF()
3529 {
3530  ((TH2F&)h2f).Copy(*this);
3531 }
3532 
3533 
3534 ////////////////////////////////////////////////////////////////////////////////
3535 /// Copy.
3536 
3537 void TH2F::Copy(TObject &newth2) const
3538 {
3539  TH2::Copy((TH2F&)newth2);
3540 }
3541 
3542 
3543 ////////////////////////////////////////////////////////////////////////////////
3544 /// Reset this histogram: contents, errors, etc.
3545 
3546 void TH2F::Reset(Option_t *option)
3547 {
3548  TH2::Reset(option);
3549  TArrayF::Reset();
3550 }
3551 
3552 
3553 ////////////////////////////////////////////////////////////////////////////////
3554 /// Set total number of bins including under/overflow
3555 /// Reallocate bin contents array
3556 
3558 {
3559  if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
3560  fNcells = n;
3561  TArrayF::Set(n);
3562 }
3563 
3564 
3565 ////////////////////////////////////////////////////////////////////////////////
3566 /// Stream an object of class TH2F.
3567 
3568 void TH2F::Streamer(TBuffer &R__b)
3569 {
3570  if (R__b.IsReading()) {
3571  UInt_t R__s, R__c;
3572  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
3573  if (R__v > 2) {
3574  R__b.ReadClassBuffer(TH2F::Class(), this, R__v, R__s, R__c);
3575  return;
3576  }
3577  //====process old versions before automatic schema evolution
3578  if (R__v < 2) {
3579  R__b.ReadVersion();
3580  TH1::Streamer(R__b);
3581  TArrayF::Streamer(R__b);
3582  R__b.ReadVersion();
3583  R__b >> fScalefactor;
3584  R__b >> fTsumwy;
3585  R__b >> fTsumwy2;
3586  R__b >> fTsumwxy;
3587  } else {
3588  TH2::Streamer(R__b);
3589  TArrayF::Streamer(R__b);
3590  R__b.CheckByteCount(R__s, R__c, TH2F::IsA());
3591  }
3592  //====end of old versions
3593 
3594  } else {
3595  R__b.WriteClassBuffer(TH2F::Class(),this);
3596  }
3597 }
3598 
3599 
3600 ////////////////////////////////////////////////////////////////////////////////
3601 /// Operator =
3602 
3604 {
3605  if (this != &h1) ((TH2F&)h1).Copy(*this);
3606  return *this;
3607 }
3608 
3609 
3610 ////////////////////////////////////////////////////////////////////////////////
3611 /// Operator *
3612 
3614 {
3615  TH2F hnew = h1;
3616  hnew.Scale(c1);
3617  hnew.SetDirectory(0);
3618  return hnew;
3619 }
3620 
3621 
3622 ////////////////////////////////////////////////////////////////////////////////
3623 /// Operator *
3624 
3626 {
3627  TH2F hnew = h1;
3628  hnew.Scale(c1);
3629  hnew.SetDirectory(0);
3630  return hnew;
3631 }
3632 
3633 
3634 ////////////////////////////////////////////////////////////////////////////////
3635 /// Operator +
3636 
3638 {
3639  TH2F hnew = h1;
3640  hnew.Add(&h2,1);
3641  hnew.SetDirectory(0);
3642  return hnew;
3643 }
3644 
3645 
3646 ////////////////////////////////////////////////////////////////////////////////
3647 /// Operator -
3648 
3650 {
3651  TH2F hnew = h1;
3652  hnew.Add(&h2,-1);
3653  hnew.SetDirectory(0);
3654  return hnew;
3655 }
3656 
3657 
3658 ////////////////////////////////////////////////////////////////////////////////
3659 /// Operator *
3660 
3662 {
3663  TH2F hnew = h1;
3664  hnew.Multiply(&h2);
3665  hnew.SetDirectory(0);
3666  return hnew;
3667 }
3668 
3669 
3670 ////////////////////////////////////////////////////////////////////////////////
3671 /// Operator /
3672 
3674 {
3675  TH2F hnew = h1;
3676  hnew.Divide(&h2);
3677  hnew.SetDirectory(0);
3678  return hnew;
3679 }
3680 
3681 
3682 //______________________________________________________________________________
3683 // TH2D methods
3684 // TH2D a 2-D histogram with eight bytes per cell (double)
3685 //______________________________________________________________________________
3686 
3687 ClassImp(TH2D)
3688 
3689 
3690 ////////////////////////////////////////////////////////////////////////////////
3691 /// Constructor.
3692 
3694 {
3695  SetBinsLength(9);
3696  if (fgDefaultSumw2) Sumw2();
3697 }
3698 
3699 
3700 ////////////////////////////////////////////////////////////////////////////////
3701 /// Destructor.
3702 
3704 {
3705 }
3706 
3707 
3708 ////////////////////////////////////////////////////////////////////////////////
3709 /// Constructor.
3710 
3711 TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3712  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3713  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
3714 {
3716  if (fgDefaultSumw2) Sumw2();
3717 
3718  if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
3719 }
3720 
3721 
3722 ////////////////////////////////////////////////////////////////////////////////
3723 /// Constructor.
3724 
3725 TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3726  ,Int_t nbinsy,Double_t ylow,Double_t yup)
3727  :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
3728 {
3730  if (fgDefaultSumw2) Sumw2();
3731 }
3732 
3733 
3734 ////////////////////////////////////////////////////////////////////////////////
3735 /// Constructor.
3736 
3737 TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
3738  ,Int_t nbinsy,const Double_t *ybins)
3739  :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
3740 {
3742  if (fgDefaultSumw2) Sumw2();
3743 }
3744 
3745 
3746 ////////////////////////////////////////////////////////////////////////////////
3747 /// Constructor.
3748 
3749 TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
3750  ,Int_t nbinsy,const Double_t *ybins)
3751  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3752 {
3754  if (fgDefaultSumw2) Sumw2();
3755 }
3756 
3757 
3758 ////////////////////////////////////////////////////////////////////////////////
3759 /// Constructor.
3760 
3761 TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
3762  ,Int_t nbinsy,const Float_t *ybins)
3763  :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
3764 {
3766  if (fgDefaultSumw2) Sumw2();
3767 }
3768 
3769 
3770 ////////////////////////////////////////////////////////////////////////////////
3771 /// Constructor.
3772 
3774 :TH2("TMatrixDBase","",m.GetNcols(),m.GetColLwb(),1+m.GetColUpb(),m.GetNrows(),m.GetRowLwb(),1+m.GetRowUpb())
3775 {
3777  Int_t ilow = m.GetRowLwb();
3778  Int_t iup = m.GetRowUpb();
3779  Int_t jlow = m.GetColLwb();
3780  Int_t jup = m.GetColUpb();
3781  for (Int_t i=ilow;i<=iup;i++) {
3782  for (Int_t j=jlow;j<=jup;j++) {
3783  SetBinContent(j-jlow+1,i-ilow+1,m(i,j));
3784  }
3785  }
3786  if (fgDefaultSumw2) Sumw2();
3787 }
3788 
3789 
3790 ////////////////////////////////////////////////////////////////////////////////
3791 /// Copy constructor.
3792 
3793 TH2D::TH2D(const TH2D &h2d) : TH2(), TArrayD()
3794 {
3795  ((TH2D&)h2d).Copy(*this);
3796 }
3797 
3798 
3799 ////////////////////////////////////////////////////////////////////////////////
3800 /// Copy.
3801 
3802 void TH2D::Copy(TObject &newth2) const
3803 {
3804  TH2::Copy((TH2D&)newth2);
3805 }
3806 
3807 
3808 ////////////////////////////////////////////////////////////////////////////////
3809 /// Reset this histogram: contents, errors, etc.
3810 
3811 void TH2D::Reset(Option_t *option)
3812 {
3813  TH2::Reset(option);
3814  TArrayD::Reset();
3815 }
3816 
3817 
3818 ////////////////////////////////////////////////////////////////////////////////
3819 /// Set total number of bins including under/overflow
3820 /// Reallocate bin contents array
3821 
3823 {
3824  if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
3825  fNcells = n;
3826  TArrayD::Set(n);
3827 }
3828 
3829 
3830 ////////////////////////////////////////////////////////////////////////////////
3831 /// Stream an object of class TH2D.
3832 
3833 void TH2D::Streamer(TBuffer &R__b)
3834 {
3835  if (R__b.IsReading()) {
3836  UInt_t R__s, R__c;
3837  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
3838  if (R__v > 2) {
3839  R__b.ReadClassBuffer(TH2D::Class(), this, R__v, R__s, R__c);
3840  return;
3841  }
3842  //====process old versions before automatic schema evolution
3843  if (R__v < 2) {
3844  R__b.ReadVersion();
3845  TH1::Streamer(R__b);
3846  TArrayD::Streamer(R__b);
3847  R__b.ReadVersion();
3848  R__b >> fScalefactor;
3849  R__b >> fTsumwy;
3850  R__b >> fTsumwy2;
3851  R__b >> fTsumwxy;
3852  } else {
3853  TH2::Streamer(R__b);
3854  TArrayD::Streamer(R__b);
3855  R__b.CheckByteCount(R__s, R__c, TH2D::IsA());
3856  }
3857  //====end of old versions
3858 
3859  } else {
3860  R__b.WriteClassBuffer(TH2D::Class(),this);
3861  }
3862 }
3863 
3864 
3865 ////////////////////////////////////////////////////////////////////////////////
3866 /// Operator =
3867 
3869 {
3870  if (this != &h1) ((TH2D&)h1).Copy(*this);
3871  return *this;
3872 }
3873 
3874 
3875 
3876 ////////////////////////////////////////////////////////////////////////////////
3877 /// Operator *
3878 
3880 {
3881  TH2D hnew = h1;
3882  hnew.Scale(c1);
3883  hnew.SetDirectory(0);
3884  return hnew;
3885 }
3886 
3887 
3888 ////////////////////////////////////////////////////////////////////////////////
3889 /// Operator +
3890 
3892 {
3893  TH2D hnew = h1;
3894  hnew.Add(&h2,1);
3895  hnew.SetDirectory(0);
3896  return hnew;
3897 }
3898 
3899 
3900 ////////////////////////////////////////////////////////////////////////////////
3901 /// Operator -
3902 
3904 {
3905  TH2D hnew = h1;
3906  hnew.Add(&h2,-1);
3907  hnew.SetDirectory(0);
3908  return hnew;
3909 }
3910 
3911 
3912 ////////////////////////////////////////////////////////////////////////////////
3913 /// Operator *
3914 
3916 {
3917  TH2D hnew = h1;
3918  hnew.Multiply(&h2);
3919  hnew.SetDirectory(0);
3920  return hnew;
3921 }
3922 
3923 
3924 ////////////////////////////////////////////////////////////////////////////////
3925 /// Operator /
3926 
3928 {
3929  TH2D hnew = h1;
3930  hnew.Divide(&h2);
3931  hnew.SetDirectory(0);
3932  return hnew;
3933 }
const int nx
Definition: kalman.C:16
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH2.cxx:3822
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title Offset is a correction factor with respect to the "s...
Definition: TAttAxis.cxx:262
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
TH1D * QuantilesX(Double_t prob=0.5, const char *name="_qx") const
Compute the X distribution of quantiles in the other variable Y name is the name of the returned hist...
Definition: TH2.cxx:2361
Bool_t IsReading() const
Definition: TBuffer.h:83
virtual Float_t GetTickLength() const
Definition: TAttAxis.h:49
virtual void Scale(Double_t c1=1, Option_t *option="")
Multiply this histogram by a constant c1.
Definition: TH1.cxx:5936
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition: TH1.cxx:3125
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition: TH2.cxx:3045
virtual Double_t GetEffectiveEntries() const
Number of effective entries of the histogram.
Definition: TH1.cxx:4078
virtual void Paint(Option_t *option="")
Control routine to paint any kind of histograms.
Definition: TH1.cxx:5538
An array of TObjects.
Definition: TObjArray.h:39
virtual void SetParameters(const Double_t *params)
Definition: TF1.h:439
float xmin
Definition: THbookFile.cxx:93
virtual void FillRandom(const char *fname, Int_t ntimes=5000)
Fill histogram following distribution in function fname.
Definition: TH2.cxx:597
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
Double_t Floor(Double_t x)
Definition: TMath.h:473
void Set(Int_t n)
Set size of this array to n chars.
Definition: TArrayC.cxx:105
friend TH2D operator+(TH2D &h1, TH2D &h2)
Operator +.
Definition: TH2.cxx:3891
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:444
virtual void GetRandom2(Double_t &x, Double_t &y)
Return 2 random numbers along axis x and y distributed according the cellcontents of a 2-dim histogra...
Definition: TH2.cxx:1075
long long Long64_t
Definition: RtypesCore.h:69
virtual Int_t BufferEmpty(Int_t action=0)
Fill histogram with all entries in the buffer.
Definition: TH2.cxx:177
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:132
void Copy(TArrayI &array) const
Definition: TArrayI.h:44
Stat_t GetSum() const
Definition: TArrayD.h:48
short Style_t
Definition: RtypesCore.h:76
friend TH2F operator/(TH2F &h1, TH2F &h2)
Operator /.
Definition: TH2.cxx:3673
Double_t Log(Double_t x)
Definition: TMath.h:526
short Version_t
Definition: RtypesCore.h:61
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
Definition: TH2.cxx:2341
static Bool_t fgDefaultSumw2
!flag to call TH1::Sumw2 automatically at histogram creation time
Definition: TH1.h:131
TVirtualHistPainter * GetPainter(Option_t *option="")
Return pointer to painter.
Definition: TH1.cxx:4099
Collectable string class.
Definition: TObjString.h:32
float Float_t
Definition: RtypesCore.h:53
virtual void SetDirectory(TDirectory *dir)
By default when an histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8051
friend TH2C operator/(TH2C &h1, TH2C &h2)
Operator /.
Definition: TH2.cxx:2936
virtual Float_t GetLabelOffset() const
Definition: TAttAxis.h:45
Short_t * fArray
Definition: TArrayS.h:32
return c
const char Option_t
Definition: RtypesCore.h:62
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:504
Double_t KolmogorovProb(Double_t z)
Calculates the Kolmogorov distribution function,.
Definition: TMath.cxx:665
return c1
Definition: legend1.C:41
void Reset()
Definition: TArrayD.h:49
float ymin
Definition: THbookFile.cxx:93
friend TH2C operator+(TH2C &h1, TH2C &h2)
Operator +.
Definition: TH2.cxx:2900
Double_t QuietNaN()
Definition: TMath.h:622
friend TH2D operator-(TH2D &h1, TH2D &h2)
Operator -.
Definition: TH2.cxx:3903
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:635
TAxis fYaxis
Y axis descriptor.
Definition: TH1.h:105
TH1D * ProjectionY(const char *name="_py", Int_t firstxbin=0, Int_t lastxbin=-1, Option_t *option="") const
Project a 2-D histogram into a 1-D histogram along Y.
Definition: TH2.cxx:2332
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
Definition: TH1.cxx:7070
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
virtual TH2 * RebinY(Int_t ngroup=2, const char *newname="")
Rebin only the Y axis see Rebin2D.
Definition: TH2.cxx:1525
virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax)
Redefine x axis parameters.
Definition: TH1.cxx:7881
Double_t fScalefactor
Definition: TH2.h:39
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
friend TH2I operator-(TH2I &h1, TH2I &h2)
Operator -.
Definition: TH2.cxx:3385
virtual Color_t GetAxisColor() const
Definition: TAttAxis.h:42
TH1 * h
Definition: legend2.C:5
static Bool_t fgStatOverflows
!flag to use under/overflows in statistics
Definition: TH1.h:130
TH2C()
Constructor.
Definition: TH2.cxx:2702
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition: TAttAxis.cxx:173
virtual Int_t BufferFill(Double_t x, Double_t y, Double_t w)
accumulate arguments in buffer.
Definition: TH2.cxx:251
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH2.cxx:3086
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4638
fill
Definition: fit1_py.py:6
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition: TAttAxis.cxx:229
virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum=0)
Compute Quantiles for this histogram Quantile x_q of a probability distribution Function F is defined...
Definition: TH1.cxx:4190
virtual void SetRange(Double_t xmin, Double_t xmax)
Initialize the upper and lower bounds to draw the function.
Definition: TF1.cxx:3240
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1102
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
TH1D * ProjectionX(const char *name="_px", Int_t firstybin=0, Int_t lastybin=-1, Option_t *option="") const
Project a 2-D histogram into a 1-D histogram along X.
Definition: TH2.cxx:2292
TH2I()
Constructor.
Definition: TH2.cxx:3210
virtual Int_t MakeCuts(char *cutsopt)=0
static THLimitsFinder * GetLimitsFinder()
Return pointer to the current finder.
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
#define gROOT
Definition: TROOT.h:364
virtual Double_t GetMean(Int_t axis=1) const
For axis = 1,2 or 3 returns the mean value of the histogram along X,Y or Z axis.
Definition: TH1.cxx:6760
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:582
virtual ~TH2D()
Destructor.
Definition: TH2.cxx:3703
Basic string class.
Definition: TString.h:137
virtual TH1D * DoQuantiles(bool onX, const char *name, Double_t prob) const
Implementation of quantiles for x or y.
Definition: TH2.cxx:2383
virtual Double_t GetCorrelationFactor(Int_t axis1=1, Int_t axis2=2) const
Return correlation factor between axis1 and axis2.
Definition: TH2.cxx:1025
tomato 2-D histogram with a byte per channel (see TH1 documentation)
Definition: TH2.h:138
Array of floats (32 bits per element).
Definition: TArrayF.h:29
virtual void SetTitleFont(Style_t font=62)
Set the title font.
Definition: TAttAxis.cxx:290
virtual Double_t Integral(Option_t *option="") const
Return integral of bin contents.
Definition: TH2.cxx:1187
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1089
int Int_t
Definition: RtypesCore.h:41
virtual ~TH2()
Destructor.
Definition: TH2.cxx:164
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
friend TH2C operator*(Float_t c1, TH2C &h1)
Operator *.
Definition: TH2.cxx:2888
virtual Double_t GetParError(Int_t ipar) const
Return value of parameter number ipar.
Definition: TF1.cxx:1642
int nbins[3]
TArrayD fSumw2
Array of sum of squares of weights.
Definition: TH1.h:118
friend TH2I operator/(TH2I &h1, TH2I &h2)
Operator /.
Definition: TH2.cxx:3409
void Copy(TArrayC &array) const
Definition: TArrayC.h:44
virtual Float_t GetLabelSize() const
Definition: TAttAxis.h:46
virtual Bool_t IsInside(Int_t x, Int_t y)=0
void Reset()
Definition: TArrayF.h:49
Profile Historam.
Definition: TProfile.h:34
const char * Class
Definition: TXMLSetup.cxx:64
virtual Int_t FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax)
compute the best axis limits for the X axis.
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:2812
virtual Bool_t Multiply(TF1 *h1, Double_t c1=1)
Performs the operation: this = this*c1*f1 if errors are defined (see TH1::Sumw2), errors are also rec...
Definition: TH1.cxx:5363
virtual void SetShowProjectionY(Int_t nbins=1)
When the mouse is moved in a pad containing a 2-d view of this histogram a second canvas shows the pr...
Definition: TH2.cxx:2507
TH2F()
Constructor.
Definition: TH2.cxx:3429
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels The distance is expressed in per cent of the pad width...
Definition: TAttAxis.cxx:193
virtual Double_t Integral(Double_t ax, Double_t bx, Double_t ay, Double_t by, Double_t epsrel=1.e-6)
Return Integral of a 2d function in range [ax,bx],[ay,by] with desired relative accuracy (default val...
Definition: TF2.cxx:619
friend TH2I operator*(Float_t c1, TH2I &h1)
Operator *.
Definition: TH2.cxx:3361
Short_t Abs(Short_t d)
Definition: TMathBase.h:110
virtual TVirtualPad * cd(Int_t subpadnumber=0)=0
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH2.cxx:2832
friend TH2D operator/(TH2D &h1, TH2D &h2)
Operator /.
Definition: TH2.cxx:3927
Double_t Prob(Double_t chi2, Int_t ndf)
Computation of the probability for a certain Chi-squared (chi2) and number of degrees of freedom (ndf...
Definition: TMath.cxx:624
friend TH2I operator+(TH2I &h1, TH2I &h2)
Operator +.
Definition: TH2.cxx:3373
Array of integers (32 bits per element).
Definition: TArrayI.h:29
void Reset(Char_t val=0)
Definition: TArrayC.h:49
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
virtual void SetBuffer(Int_t buffersize, Option_t *option="")
Set the maximum number of entries to be kept in the buffer.
Definition: TH1.cxx:7580
Double_t fTsumwx2
Total Sum of weight*X*X.
Definition: TH1.h:113
virtual Bool_t CanExtendAllAxes() const
Returns true if all axes are extendable.
Definition: TH1.cxx:5960
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition: TH1.cxx:6418
Histogram is forced to be not weighted even when the histogram is filled with weighted different than...
Definition: TH1.h:179
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:514
virtual void SetLabelFont(Style_t font=62)
Set labels&#39; font.
Definition: TAttAxis.cxx:183
friend TH2S operator/(TH2S &h1, TH2S &h2)
Operator /.
Definition: TH2.cxx:3190
virtual Style_t GetMarkerStyle() const
Return the marker style.
Definition: TAttMarker.h:37
virtual Style_t GetTitleFont() const
Definition: TAttAxis.h:51
virtual Int_t GetDimension() const
Definition: TH1.h:287
friend TH2C operator-(TH2C &h1, TH2C &h2)
Operator -.
Definition: TH2.cxx:2912
double sqrt(double)
Double_t GetXmin() const
Definition: TAxis.h:139
static const double x2[5]
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:188
TH2S()
Constructor.
Definition: TH2.cxx:2956
virtual void Reset(Option_t *option="")
Reset contents of a Profile histogram.
Definition: TProfile.cxx:1501
Double_t x[n]
Definition: legend1.C:17
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
Definition: TString.cxx:2335
TH2F & operator=(const TH2F &h1)
Operator =.
Definition: TH2.cxx:3603
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:36
Int_t GetColLwb() const
Definition: TMatrixTBase.h:135
virtual Int_t ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05)
Interface to TSpectrum2::Search the function finds peaks in this histogram where the width is > sigma...
Definition: TH2.cxx:2536
const int ny
Definition: kalman.C:17
THashList * GetLabels() const
Definition: TAxis.h:123
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:3066
virtual TArrayD * GetBinSumw2()
Definition: TProfile.h:111
virtual void SetShowProjectionX(Int_t nbins=1)
When the mouse is moved in a pad containing a 2-d view of this histogram a second canvas shows the pr...
Definition: TH2.cxx:2492
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:464
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition: TAttMarker.h:43
Double_t * fArray
Definition: TArrayD.h:32
TH2S & operator=(const TH2S &h1)
Operator =.
Definition: TH2.cxx:3132
Double_t fTsumwy2
Definition: TH2.h:41
friend TH2F operator-(TH2F &h1, TH2F &h2)
Operator -.
Definition: TH2.cxx:3649
const Double_t sigma
Ssiz_t First(char c) const
Find first occurrence of a character c.
Definition: TString.cxx:467
TH1F * h1
Definition: legend1.C:5
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition: TH1.cxx:1193
virtual void ResetStats()
Reset the statistics including the number of entries and replace with values calculates from bin cont...
Definition: TH1.cxx:7085
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:59
void Set(Int_t n)
Set size of this array to n ints.
Definition: TArrayI.cxx:105
virtual void Reset(Option_t *option="")
Reset.
Definition: TH1.cxx:9386
virtual void SetBinError(Int_t bin, Double_t error)
See convention for numbering bins in TH1::GetBin.
Definition: TH1.cxx:8309
virtual Double_t ComputeIntegral(Bool_t onlyPositive=false)
Compute integral (cumulative sum of bins) The result stored in fIntegral is used by the GetRandom fun...
Definition: TH1.cxx:2355
virtual Color_t GetLabelColor() const
Definition: TAttAxis.h:43
short Color_t
Definition: RtypesCore.h:79
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition: TH2.cxx:2791
Double_t fTsumwx
Total Sum of weight*X.
Definition: TH1.h:112
virtual Bool_t Divide(TF1 *f1, Double_t c1=1)
Performs the operation: this = this/(c1*f1) if errors are defined (see TH1::Sumw2), errors are also recalculated.
Definition: TH1.cxx:2606
virtual Int_t GetNdivisions() const
Definition: TAttAxis.h:41
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:3320
void Set(Int_t n)
Set size of this array to n shorts.
Definition: TArrayS.cxx:105
virtual Double_t Rndm()
Machine independent random number generator.
Definition: TRandom.cxx:512
virtual void ImportAttributes(const TAxis *axis)
Copy axis attributes to this.
Definition: TAxis.cxx:616
virtual void Smooth(Int_t ntimes=1, Option_t *option="")
Smooth bin contents of this 2-d histogram using kernel algorithms similar to the ones used in the ras...
Definition: TH2.cxx:2565
virtual Int_t FindFirstBinAbove(Double_t threshold=0, Int_t axis=1) const
Find first bin with content > threshold for axis (1=x, 2=y, 3=z) if no bins with content > threshold ...
Definition: TH2.cxx:680
virtual const char * GetParName(Int_t ipar) const
Definition: TF1.h:370
virtual void ExtendAxis(Double_t x, TAxis *axis)
Histogram is resized along axis such that x is in the axis range.
Definition: TH1.cxx:5838
virtual Double_t GetBinWithContent2(Double_t c, Int_t &binx, Int_t &biny, Int_t firstxbin=1, Int_t lastxbin=-1, Int_t firstybin=1, Int_t lastybin=-1, Double_t maxdiff=0) const
compute first cell (binx,biny) in the range [firstxbin,lastxbin][firstybin,lastybin] for which diff =...
Definition: TH2.cxx:997
void Reset()
Definition: TArrayS.h:49
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition: TH2.cxx:2821
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:46
Int_t fN
Definition: TArray.h:40
float ymax
Definition: THbookFile.cxx:93
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:279
void Copy(TArrayF &array) const
Definition: TArrayF.h:44
virtual ~TH2C()
Destructor.
Definition: TH2.cxx:2712
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition: TH2.cxx:3299
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:455
const char * GetTitle() const
Returns title of object.
Definition: TAxis.h:135
Service class for 2-Dim histogram classes.
Definition: TH2.h:36
Class to manage histogram axis.
Definition: TAxis.h:36
virtual void GetStats(Double_t *stats) const
Fill the array stats from the contents of this histogram The array stats must be correctly dimensionn...
Definition: TH2.cxx:1128
virtual void Draw(Option_t *option="")
Draw this histogram with options.
Definition: TH1.cxx:2851
Array of shorts (16 bits per element).
Definition: TArrayS.h:29
Int_t GetSize() const
Definition: TArray.h:49
TH2C & operator=(const TH2C &h1)
Operator =.
Definition: TH2.cxx:2878
virtual void FitSlicesX(TF1 *f1=0, Int_t firstybin=0, Int_t lastybin=-1, Int_t cut=0, Option_t *option="QNR", TObjArray *arr=0)
Project slices along X in case of a 2-D histogram, then fit each slice with function f1 and make a hi...
Definition: TH2.cxx:896
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:42
virtual Int_t GetNumberFitPoints() const
Definition: TF1.h:356
tomato 2-D histogram with a float per channel (see TH1 documentation)}
Definition: TH2.h:255
Double_t fTsumwxy
Definition: TH2.h:42
unsigned int r1[N_CITIES]
Definition: simanTSP.cxx:321
Double_t fTsumwy
Definition: TH2.h:40
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:488
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:8323
static Int_t fgBufferSize
!default buffer size for automatic histograms
Definition: TH1.h:128
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:3802
Double_t fEntries
Number of entries.
Definition: TH1.h:109
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual Float_t GetTitleOffset() const
Definition: TAttAxis.h:47
TMarker * m
Definition: textangle.C:8
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
char * Form(const char *fmt,...)
virtual void Copy(TObject &hnew) const
Copy this histogram structure to newth1.
Definition: TH1.cxx:2468
short Short_t
Definition: RtypesCore.h:35
Int_t Fill(const Double_t *v)
Definition: TProfile.h:56
virtual void SetMarkerStyle(Style_t mstyle=1)
Set the marker style.
Definition: TAttMarker.h:45
TAxis * GetYaxis()
Definition: TH1.h:325
float xmax
Definition: THbookFile.cxx:93
virtual Color_t GetTitleColor() const
Definition: TAttAxis.h:50
Double_t * fIntegral
!Integral of bins used by GetRandom
Definition: TH1.h:125
virtual Double_t IntegralAndError(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Double_t &err, Option_t *option="") const
Return integral of bin contents in range [firstxbin,lastxbin],[firstybin,lastybin] for a 2-D histogra...
Definition: TH2.cxx:1216
A 2-Dim function with parameters.
Definition: TF2.h:33
Int_t GetColUpb() const
Definition: TMatrixTBase.h:136
R__EXTERN TRandom * gRandom
Definition: TRandom.h:66
tomato 1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:618
virtual Int_t GetBin(Int_t binx, Int_t biny=0, Int_t binz=0) const
Return Global bin number corresponding to binx,y,z.
Definition: TH1.cxx:4540
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition: TAttAxis.cxx:163
TString & String()
Definition: TObjString.h:52
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels The size is expressed in per cent of the pad width.
Definition: TAttAxis.cxx:204
Linear Algebra Package.
virtual void SetTitleColor(Color_t color=1)
Set color of axis title.
Definition: TAttAxis.cxx:281
virtual void SetTitleSize(Float_t size=0.04)
Set size of axis title The size is expressed in per cent of the pad width.
Definition: TAttAxis.cxx:272
virtual Double_t RetrieveBinContent(Int_t bin) const
Raw retrieval of bin content on internal data structure see convention for numbering bins in TH1::Get...
Definition: TH1.cxx:8541
Double_t Gaus(Double_t x, Double_t mean=0, Double_t sigma=1, Bool_t norm=kFALSE)
Calculate a gaussian function with mean and sigma.
Definition: TMath.cxx:452
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:39
TH1D * QuantilesY(Double_t prob=0.5, const char *name="_qy") const
Compute the Y distribution of quantiles in the other variable X name is the name of the returned hist...
Definition: TH2.cxx:2374
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:279
friend TH2D operator*(Float_t c1, TH2D &h1)
Operator *.
Definition: TH2.cxx:3879
virtual void SetName(const char *name)
Change the name of this histogram.
Definition: TH1.cxx:8071
TString & Remove(Ssiz_t pos)
Definition: TString.h:616
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
virtual Int_t GetSumw2N() const
Definition: TH1.h:319
Double_t GetChisquare() const
Definition: TF1.h:336
Double_t fTsumw2
Total Sum of squares of weights.
Definition: TH1.h:111
friend TH2F operator+(TH2F &h1, TH2F &h2)
Operator +.
Definition: TH2.cxx:3637
friend TH2S operator*(Float_t c1, TH2S &h1)
Operator *.
Definition: TH2.cxx:3142
TH2D()
Constructor.
Definition: TH2.cxx:3693
virtual TH2 * RebinX(Int_t ngroup=2, const char *newname="")
Rebin only the X axis see Rebin2D.
Definition: TH2.cxx:1515
static const double x1[5]
#define ClassImp(name)
Definition: Rtypes.h:279
double f(double x)
TProfile * ProfileY(const char *name="_pfy", Int_t firstxbin=1, Int_t lastxbin=-1, Option_t *option="") const
Project a 2-D histogram into a profile histogram along Y.
Definition: TH2.cxx:2014
TProfile * ProfileX(const char *name="_pfx", Int_t firstybin=1, Int_t lastybin=-1, Option_t *option="") const
Project a 2-D histogram into a profile histogram along X.
Definition: TH2.cxx:1964
TH2I & operator=(const TH2I &h1)
Operator =.
Definition: TH2.cxx:3351
double Double_t
Definition: RtypesCore.h:55
virtual void DoFitSlices(bool onX, TF1 *f1, Int_t firstbin, Int_t lastbin, Int_t cut, Option_t *option, TObjArray *arr)
Definition: TH2.cxx:738
Int_t * fArray
Definition: TArrayI.h:32
Double_t fTsumw
Total Sum of weights.
Definition: TH1.h:110
virtual void SetShowProjection(const char *option, Int_t nbins)=0
virtual void FitSlicesY(TF1 *f1=0, Int_t firstxbin=0, Int_t lastxbin=-1, Int_t cut=0, Option_t *option="QNR", TObjArray *arr=0)
Project slices along Y in case of a 2-D histogram, then fit each slice with function f1 and make a hi...
Definition: TH2.cxx:961
unsigned long ULong_t
Definition: RtypesCore.h:51
int nentries
Definition: THbookFile.cxx:89
Double_t y[n]
Definition: legend1.C:17
virtual void Expand(Int_t newSize)
Expand or shrink the array to newSize elements.
Definition: TObjArray.cxx:370
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:35
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:567
The TH1 histogram class.
Definition: TH1.h:80
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
virtual Double_t GetEntries() const
Return the current number of entries.
Definition: TH1.cxx:4053
tomato 2-D histogram with a short per channel (see TH1 documentation)
Definition: TH2.h:177
virtual void SetBinLabel(Int_t bin, const char *label)
Set label for bin.
Definition: TAxis.cxx:808
virtual Float_t GetTitleSize() const
Definition: TAttAxis.h:48
virtual Int_t FindLastBinAbove(Double_t threshold=0, Int_t axis=1) const
Find last bin with content > threshold for axis (1=x, 2=y, 3=z) if no bins with content > threshold i...
Definition: TH2.cxx:710
Array of doubles (64 bits per element).
Definition: TArrayD.h:29
friend TH2F operator*(Float_t c1, TH2F &h1)
Operator *.
Definition: TH2.cxx:3613
Bool_t IsNull() const
Definition: TString.h:387
virtual Bool_t Add(TF1 *h1, Double_t c1=1, Option_t *option="")
Performs the operation: this = this + c1*f1 if errors are defined (see TH1::Sumw2), errors are also recalculated.
Definition: TH1.cxx:770
void SetBins(const Int_t *nbins, const Double_t *range)
Definition: TProfile.h:55
Mother of all ROOT objects.
Definition: TObject.h:37
you should not use this method at all Int_t Int_t z
Definition: TRolke.cxx:630
char Char_t
Definition: RtypesCore.h:29
virtual TH1 * ShowBackground(Int_t niter=20, Option_t *option="same")
This function calculates the background spectrum in this histogram.
Definition: TH2.cxx:2520
virtual ~TH2F()
Destructor.
Definition: TH2.cxx:3439
virtual Int_t GetNpar() const
Definition: TF1.h:349
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:526
virtual Double_t Interpolate(Double_t x)
illegal for a TH2
Definition: TH2.cxx:1225
TVirtualHistPainter * fPainter
!pointer to histogram painter
Definition: TH1.h:126
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH2.cxx:3557
virtual ~TH2I()
Destructor.
Definition: TH2.cxx:3220
Int_t fBufferSize
fBuffer size
Definition: TH1.h:121
virtual Double_t GetParameter(Int_t ipar) const
Definition: TF1.h:359
virtual Double_t GetBinErrorSqUnchecked(Int_t bin) const
Definition: TH1.h:443
virtual Double_t DoIntegral(Int_t ix1, Int_t ix2, Int_t iy1, Int_t iy2, Int_t iz1, Int_t iz2, Double_t &err, Option_t *opt, Bool_t doerr=kFALSE) const
Internal function compute integral and optionally the error between the limits specified by the bin n...
Definition: TH1.cxx:7160
virtual void Copy(TObject &hnew) const
Copy.
Definition: TH2.cxx:3537
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:202
1-Dim function class
Definition: TF1.h:149
virtual void SetBinsLength(Int_t=-1)
Definition: TH1.h:377
Char_t * fArray
Definition: TArrayC.h:32
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition: TH1.cxx:8130
TObject * Clone(const char *newname=0) const
Make a complete copy of the underlying object.
Definition: TH1.cxx:2544
TF1 * f1
Definition: legend1.C:11
#define NULL
Definition: Rtypes.h:82
#define snprintf
Definition: civetweb.c:822
Int_t fDimension
!Histogram dimension (1, 2 or 3 dim)
Definition: TH1.h:124
THist< 1, double, THistStatContent, THistStatUncertainty > TH1D
Definition: THist.hxx:301
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH2.h:90
#define gPad
Definition: TVirtualPad.h:289
void Reset()
Definition: TArrayI.h:49
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length The length is expressed in per cent of the pad width.
Definition: TAttAxis.cxx:249
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH2.cxx:3340
virtual Double_t * GetParameters() const
Definition: TF1.h:365
void Set(Int_t n)
Set size of this array to n floats.
Definition: TArrayF.cxx:105
Int_t GetRowUpb() const
Definition: TMatrixTBase.h:133
virtual void SetEntries(Double_t n)
Definition: TH1.h:387
TAxis fXaxis
X axis descriptor.
Definition: TH1.h:104
#define gDirectory
Definition: TDirectory.h:221
friend TH2S operator+(TH2S &h1, TH2S &h2)
Operator +.
Definition: TH2.cxx:3154
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content.
Definition: TH2.cxx:2475
virtual Color_t GetMarkerColor() const
Return the marker color.
Definition: TAttMarker.h:36
virtual Int_t GetNbinsX() const
Definition: TH1.h:301
Double_t Sqrt(Double_t x)
Definition: TMath.h:464
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition: TH2.cxx:2459
Int_t GetNbins() const
Definition: TAxis.h:127
tomato 2-D histogram with an int per channel (see TH1 documentation)}
Definition: TH2.h:216
virtual void Sumw2(Bool_t flag=kTRUE)
Create/delete structure to store sum of squares of weights per bin — This is needed to compute the c...
Definition: TProfile.cxx:1730
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition: TAxis.cxx:716
virtual Int_t GetBin(Int_t binx, Int_t biny, Int_t binz=0) const
Return Global bin number corresponding to binx,y,z.
Definition: TH2.cxx:966
const Bool_t kTRUE
Definition: Rtypes.h:91
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:292
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:155
TH2()
Constructor.
Definition: TH2.cxx:60
Double_t * fBuffer
[fBufferSize] entry buffer
Definition: TH1.h:122
virtual ~TH2S()
Destructor.
Definition: TH2.cxx:2966
virtual TFitResultPtr Fit(const char *formula, Option_t *option="", Option_t *goption="", Double_t xmin=0, Double_t xmax=0)
Fit histogram with function fname.
Definition: TH1.cxx:3563
friend TH2S operator-(TH2S &h1, TH2S &h2)
Operator -.
Definition: TH2.cxx:3166
double norm(double *x, double *p)
Definition: unuranDistr.cxx:40
virtual void UpdateBinContent(Int_t bin, Double_t content)
Raw update of bin content on internal data structure see convention for numbering bins in TH1::GetBin...
Definition: TH1.cxx:8551
virtual Double_t GetStdDev(Int_t axis=1) const
Returns the Standard Deviation (Sigma).
Definition: TH1.cxx:6814
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:105
Double_t GetXmax() const
Definition: TAxis.h:140
void Copy(TArrayD &array) const
Definition: TArrayD.h:44
const Int_t n
Definition: legend1.C:16
virtual TProfile * DoProfile(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
Definition: TH2.cxx:1739
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Definition: TMath.h:931
char name[80]
Definition: TGX11.cxx:109
const TArrayD * GetXbins() const
Definition: TAxis.h:136
virtual void FillN(Int_t, const Double_t *, const Double_t *, Int_t)
Fill this histogram with an array x and weights w.
Definition: TH2.h:80
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:911
TAxis * GetXaxis()
Definition: TH1.h:324
virtual Style_t GetLabelFont() const
Definition: TAttAxis.h:44
virtual TH2 * Rebin2D(Int_t nxgroup=2, Int_t nygroup=2, const char *newname="")
Rebin this histogram grouping nxgroup/nygroup bins along the xaxis/yaxis together.
Definition: TH2.cxx:1557
void Copy(TArrayS &array) const
Definition: TArrayS.h:44
virtual Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const
Statistical test of compatibility in shape between THIS histogram and h2, using Kolmogorov test...
Definition: TH2.cxx:1343
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:52
virtual Int_t GetNbinsY() const
Definition: TH1.h:302
virtual Double_t GetBinError(Int_t bin) const
Return value of error associated to bin number bin.
Definition: TH1.cxx:8173
virtual TH1D * DoProjection(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
Internal (protected) method for performing projection on the X or Y axis called by ProjectionX or Pro...
Definition: TH2.cxx:2024
TH2D & operator=(const TH2D &h1)
Operator =.
Definition: TH2.cxx:3868
Int_t fNcells
number of bins(1D), cells (2D) +U/Overflows
Definition: TH1.h:103
virtual Double_t GetCovariance(Int_t axis1=1, Int_t axis2=2) const
Return covariance between axis1 and axis2.
Definition: TH2.cxx:1043
tomato 2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:296
const char * Data() const
Definition: TString.h:349
Array of chars or bytes (8 bits per element).
Definition: TArrayC.h:29