Logo ROOT  
Reference Guide
TH2Poly.cxx
Go to the documentation of this file.
1 // @(#)root/hist:$Id$
2 // TH2Poly v2.1
3 // Author: Olivier Couet, Deniz Gunceler, Danilo Piparo
4 
5 /*************************************************************************
6  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
7  * All rights reserved. *
8  * *
9  * For the licensing terms see $ROOTSYS/LICENSE. *
10  * For the list of contributors see $ROOTSYS/README/CREDITS. *
11  *************************************************************************/
12 
13 #include "TH2Poly.h"
14 #include "TMultiGraph.h"
15 #include "TGraph.h"
16 #include "Riostream.h"
17 #include "TList.h"
18 #include "TMath.h"
19 #include <cassert>
20 
22 
23 /** \class TH2Poly
24  \ingroup Hist
25 2D Histogram with Polygonal Bins
26 
27 ## Overview
28 `TH2Poly` is a 2D Histogram class (TH2) allowing to define polygonal
29 bins of arbitrary shape.
30 
31 Each bin in the `TH2Poly` histogram is a `TH2PolyBin` object.
32 `TH2PolyBin` is a very simple class containing the vertices (stored
33 as `TGraph`s or `TMultiGraph`s ) and contents of the polygonal
34 bin as well as several related functions.
35 
36 Essentially, a `TH2Poly` is a TList of `TH2PolyBin` objects
37 with methods to manipulate them.
38 
39 Bins are defined using one of the `AddBin()` methods. The bin definition
40 should be done before filling.
41 
42 The histogram can be filled with `Fill(Double_t x, Double_t y, Double_t w)
43 `. `w` is the weight.
44 If no weight is specified, it is assumed to be 1.
45 
46 Not all histogram's area need to be binned. Filling an area without bins,
47 will falls into the overflows. Adding a bin is not retroactive; it doesn't
48 affect previous fillings. A `Fill()` call, that
49 was previously ignored due to the lack of a bin at the specified location, is
50 not reconsidered when that location is binned later.
51 
52 If there are two overlapping bins, the first one in the list will be incremented
53 by `Fill()`.
54 
55 The histogram may automatically extends its limits if a bin outside the
56 histogram limits is added. This is done when the default constructor (with no
57 arguments) is used. It generates a histogram with no limits along the X and Y
58 axis. Adding bins to it will extend it up to a proper size.
59 
60 `TH2Poly` implements a partitioning algorithm to speed up bins' filling
61 (see the "Partitioning Algorithm" section for details).
62 The partitioning algorithm divides the histogram into regions called cells.
63 The bins that each cell intersects are recorded in an array of `TList`s.
64 When a coordinate in the histogram is to be filled; the method (quickly) finds
65 which cell the coordinate belongs. It then only loops over the bins
66 intersecting that cell to find the bin the input coordinate corresponds to.
67 The partitioning of the histogram is updated continuously as each bin is added.
68 The default number of cells on each axis is 25. This number could be set to
69 another value in the constructor or adjusted later by calling the
70 `ChangePartition(Int_t, Int_t)` method. The partitioning algorithm is
71 considerably faster than the brute force algorithm (i.e. checking if each bin
72 contains the input coordinates), especially if the histogram is to be filled
73 many times.
74 
75 The following very simple macro shows how to build and fill a `TH2Poly`:
76 ~~~ {.cpp}
77 {
78  TH2Poly *h2p = new TH2Poly();
79 
80  Double_t x1[] = {0, 5, 6};
81  Double_t y1[] = {0, 0, 5};
82  Double_t x2[] = {0, -1, -1, 0};
83  Double_t y2[] = {0, 0, -1, 3};
84  Double_t x3[] = {4, 3, 0, 1, 2.4};
85  Double_t y3[] = {4, 3.7, 1, 3.7, 2.5};
86 
87  h2p->AddBin(3, x1, y1);
88  h2p->AddBin(4, x2, y2);
89  h2p->AddBin(5, x3, y3);
90 
91  h2p->Fill(0.1, 0.01, 3);
92  h2p->Fill(-0.5, -0.5, 7);
93  h2p->Fill(-0.7, -0.5, 1);
94  h2p->Fill(1, 3, 1.5);
95 }
96 ~~~
97 
98 More examples can be found in th2polyBoxes.C, th2polyEurope.C, th2polyHoneycomb.C
99 and th2polyUSA.C.
100 
101 ## Partitioning Algorithm
102 The partitioning algorithm forms an essential part of the `TH2Poly`
103 class. It is implemented to speed up the filling of bins.
104 
105 With the brute force approach, the filling is done in the following way: An
106 iterator loops over all bins in the `TH2Poly` and invokes the
107 method `IsInside()` for each of them.
108 This method checks if the input location is in that bin. If the filling
109 coordinate is inside, the bin is filled. Looping over all the bin is
110 very slow.
111 
112 The alternative is to divide the histogram into virtual rectangular regions
113 called "cells". Each cell stores the pointers of the bins intersecting it.
114 When a coordinate is to be filled, the method finds which cell the coordinate
115 falls into. Since the cells are rectangular, this can be done very quickly.
116 It then only loops over the bins associated with that cell and calls `IsInside()`
117 only on that bins. This reduces considerably the number of bins on which `IsInside()`
118 is called and therefore speed up by a huge factor the filling compare to the brute force
119 approach where `IsInside()` is called for all bins.
120 
121 The addition of bins to the appropriate cells is done when the bin is added
122 to the histogram. To do this, `AddBin()` calls the
123 `AddBinToPartition()` method.
124 This method adds the input bin to the partitioning matrix.
125 
126 The number of partition cells per axis can be specified in the constructor.
127 If it is not specified, the default value of 25 along each axis will be
128 assigned. This value was chosen because it is small enough to avoid slowing
129 down AddBin(), while being large enough to enhance Fill() by a considerable
130 amount. Regardless of how it is initialized at construction time, it can be
131 changed later with the `ChangePartition()` method.
132 `ChangePartition()` deletes the
133 old partition matrix and generates a new one with the specified number of cells
134 on each axis.
135 
136 The optimum number of partition cells per axis changes with the number of
137 times `Fill()` will be called. Although partitioning greatly speeds up
138 filling, it also adds a constant time delay into the code. When `Fill()`
139 is to be called many times, it is more efficient to divide the histogram into
140 a large number cells. However, if the histogram is to be filled only a few
141 times, it is better to divide into a small number of cells.
142 */
143 
144 ////////////////////////////////////////////////////////////////////////////////
145 /// Default Constructor. No boundaries specified.
146 
148 {
149  Initialize(0., 0., 0., 0., 25, 25);
150  SetName("NoName");
151  SetTitle("NoTitle");
152  SetFloat();
153 }
154 
155 ////////////////////////////////////////////////////////////////////////////////
156 /// Constructor with specified name and boundaries,
157 /// but no partition cell number.
158 
159 TH2Poly::TH2Poly(const char *name,const char *title, Double_t xlow,Double_t xup
160  , Double_t ylow,Double_t yup)
161 {
162  Initialize(xlow, xup, ylow, yup, 25, 25);
163  SetName(name);
164  SetTitle(title);
165  SetFloat(kFALSE);
166 }
167 
168 ////////////////////////////////////////////////////////////////////////////////
169 /// Constructor with specified name and boundaries and partition cell number.
170 
171 TH2Poly::TH2Poly(const char *name,const char *title,
172  Int_t nX, Double_t xlow, Double_t xup,
173  Int_t nY, Double_t ylow, Double_t yup)
174 {
175  Initialize(xlow, xup, ylow, yup, nX, nY);
176  SetName(name);
177  SetTitle(title);
178  SetFloat(kFALSE);
179 }
180 
181 ////////////////////////////////////////////////////////////////////////////////
182 /// Destructor.
183 
185 {
186  delete[] fCells;
187  delete[] fIsEmpty;
188  delete[] fCompletelyInside;
189  // delete at the end the bin List since it owns the objects
190  delete fBins;
191 }
192 
193 ////////////////////////////////////////////////////////////////////////////////
194 /// Create appropriate histogram bin.
195 /// e.g. TH2Poly creates TH2PolyBin,
196 /// TProfile2Poly creates TProfile2PolyBin
197 /// This is done so that TH2Poly::AddBin does not have to be duplicated,
198 /// but only create needs to be reimplemented for additional histogram types
199 
201 {
202  if (!poly) return 0;
203 
204  if (fBins == 0) {
205  fBins = new TList();
206  fBins->SetOwner();
207  }
208 
209  fNcells++;
210  Int_t ibin = fNcells - kNOverflow;
211  // if structure fsumw2 is created extend it
212  if (fSumw2.fN) fSumw2.Set(fNcells);
213  return new TH2PolyBin(poly, ibin);
214 }
215 
216 ////////////////////////////////////////////////////////////////////////////////
217 /// Adds a new bin to the histogram. It can be any object having the method
218 /// IsInside(). It returns the bin number in the histogram. It returns 0 if
219 /// it failed to add. To allow the histogram limits to expand when a bin
220 /// outside the limits is added, call SetFloat() before adding the bin.
221 
223 {
224  auto *bin = CreateBin(poly);
225  Int_t ibin = fNcells-kNOverflow;
226  if(!bin) return 0;
227 
228  // If the bin lies outside histogram boundaries, then extends the boundaries.
229  // Also changes the partition information accordingly
230  Bool_t flag = kFALSE;
231  if (fFloat) {
232  if (fXaxis.GetXmin() > bin->GetXMin()) {
233  fXaxis.Set(100, bin->GetXMin(), fXaxis.GetXmax());
234  flag = kTRUE;
235  }
236  if (fXaxis.GetXmax() < bin->GetXMax()) {
237  fXaxis.Set(100, fXaxis.GetXmin(), bin->GetXMax());
238  flag = kTRUE;
239  }
240  if (fYaxis.GetXmin() > bin->GetYMin()) {
241  fYaxis.Set(100, bin->GetYMin(), fYaxis.GetXmax());
242  flag = kTRUE;
243  }
244  if (fYaxis.GetXmax() < bin->GetYMax()) {
245  fYaxis.Set(100, fYaxis.GetXmin(), bin->GetYMax());
246  flag = kTRUE;
247  }
248  if (flag) ChangePartition(fCellX, fCellY);
249  } else {
250  /*Implement polygon clipping code here*/
251  }
252 
253  fBins->Add((TObject*) bin);
255 
256  // Adds the bin to the partition matrix
257  AddBinToPartition(bin);
258 
259  return ibin;
260 }
261 
262 ////////////////////////////////////////////////////////////////////////////////
263 /// Adds a new bin to the histogram. The number of vertices and their (x,y)
264 /// coordinates are required as input. It returns the bin number in the
265 /// histogram.
266 
268 {
269  TGraph *g = new TGraph(n, x, y);
270  Int_t bin = AddBin(g);
271  return bin;
272 }
273 
274 ////////////////////////////////////////////////////////////////////////////////
275 /// Add a new bin to the histogram. The bin shape is a rectangle.
276 /// It returns the bin number of the bin in the histogram.
277 
279 {
280  Double_t x[] = {x1, x1, x2, x2, x1};
281  Double_t y[] = {y1, y2, y2, y1, y1};
282  TGraph *g = new TGraph(5, x, y);
283  Int_t bin = AddBin(g);
284  return bin;
285 }
286 
287 ////////////////////////////////////////////////////////////////////////////////
288 /// Performs the operation: this = this + c1*h1.
289 
291 {
292  Int_t bin;
293 
294  TH2Poly *h1p = (TH2Poly *)h1;
295 
296  // Check if number of bins is the same.
297  if (h1p->GetNumberOfBins() != GetNumberOfBins()) {
298  Error("Add", "Attempt to add histograms with different number of bins");
299  return kFALSE;
300  }
301 
302  // Check if the bins are the same.
303  TList *h1pBins = h1p->GetBins();
304  TH2PolyBin *thisBin, *h1pBin;
305  for (bin = 1; bin <= GetNumberOfBins(); bin++) {
306  thisBin = (TH2PolyBin *)fBins->At(bin - 1);
307  h1pBin = (TH2PolyBin *)h1pBins->At(bin - 1);
308  if (thisBin->GetXMin() != h1pBin->GetXMin() ||
309  thisBin->GetXMax() != h1pBin->GetXMax() ||
310  thisBin->GetYMin() != h1pBin->GetYMin() ||
311  thisBin->GetYMax() != h1pBin->GetYMax()) {
312  Error("Add", "Attempt to add histograms with different bin limits");
313  return kFALSE;
314  }
315  }
316 
317 
318  // Create Sumw2 if h1p has Sumw2 set
319  if (fSumw2.fN == 0 && h1p->GetSumw2N() != 0) Sumw2();
320 
321  // statistics can be preserved only in case of positive coefficients
322  // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
323  Bool_t resetStats = (c1 < 0);
324  Double_t s1[kNstat] = {0};
325  Double_t s2[kNstat] = {0};
326  if (!resetStats) {
327  // need to initialize to zero s1 and s2 since
328  // GetStats fills only used elements depending on dimension and type
329  GetStats(s1);
330  h1->GetStats(s2);
331  }
332  // get number of entries now because afterwards UpdateBinContent will change it
333  Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() );
334 
335 
336  // Perform the Add.
337  Double_t factor = 1;
338  if (h1p->GetNormFactor() != 0)
339  factor = h1p->GetNormFactor() / h1p->GetSumOfWeights();
340  for (bin = 0; bin < fNcells; bin++) {
341  Double_t y = this->RetrieveBinContent(bin) + c1 * h1p->RetrieveBinContent(bin);
342  UpdateBinContent(bin, y);
343  if (fSumw2.fN) {
344  Double_t esq = factor * factor * h1p->GetBinErrorSqUnchecked(bin);
345  fSumw2.fArray[bin] += c1 * c1 * factor * factor * esq;
346  }
347  }
348 
349  // update statistics (do here to avoid changes by SetBinContent)
350  if (resetStats) {
351  // statistics need to be reset in case coefficient are negative
352  ResetStats();
353  } else {
354  for (Int_t i = 0; i < kNstat; i++) {
355  if (i == 1) s1[i] += c1 * c1 * s2[i];
356  else s1[i] += c1 * s2[i];
357  }
358  PutStats(s1);
359  SetEntries(entries);
360  }
361  return kTRUE;
362 }
363 
364 ////////////////////////////////////////////////////////////////////////////////
365 /// Adds the input bin into the partition cell matrix. This method is called
366 /// in AddBin() and ChangePartition().
367 
369 {
370  // Cell Info
371  Int_t nl, nr, mb, mt; // Max/min indices of the cells that contain the bin
372  Double_t xclipl, xclipr, yclipb, yclipt; // x and y coordinates of a cell
373  Double_t binXmax, binXmin, binYmax, binYmin; // The max/min bin coordinates
374 
375  binXmax = bin->GetXMax();
376  binXmin = bin->GetXMin();
377  binYmax = bin->GetYMax();
378  binYmin = bin->GetYMin();
379  nl = (Int_t)(floor((binXmin - fXaxis.GetXmin())/fStepX));
380  nr = (Int_t)(floor((binXmax - fXaxis.GetXmin())/fStepX));
381  mb = (Int_t)(floor((binYmin - fYaxis.GetXmin())/fStepY));
382  mt = (Int_t)(floor((binYmax - fYaxis.GetXmin())/fStepY));
383 
384  // Make sure the array indices are correct.
385  if (nr>=fCellX) nr = fCellX-1;
386  if (mt>=fCellY) mt = fCellY-1;
387  if (nl<0) nl = 0;
388  if (mb<0) mb = 0;
389 
390  // number of cells in the grid
391  //N.B. not to be confused with fNcells (the number of bins) !
393 
394  // Loop over all cells
395  for (int i = nl; i <= nr; i++) {
396  xclipl = fXaxis.GetXmin() + i*fStepX;
397  xclipr = xclipl + fStepX;
398  for (int j = mb; j <= mt; j++) {
399  yclipb = fYaxis.GetXmin() + j*fStepY;
400  yclipt = yclipb + fStepY;
401 
402  // If the bin is completely inside the cell,
403  // add that bin to the cell then return
404  if ((binXmin >= xclipl) && (binXmax <= xclipr) &&
405  (binYmax <= yclipt) && (binYmin >= yclipb)){
406  fCells[i + j*fCellX].Add((TObject*) bin);
407  fIsEmpty[i + j*fCellX] = kFALSE; // Makes the cell non-empty
408  return;
409  }
410 
411  // If any of the sides of the cell intersect with any side of the bin,
412  // add that bin then continue
413  if (IsIntersecting(bin, xclipl, xclipr, yclipb, yclipt)) {
414  fCells[i + j*fCellX].Add((TObject*) bin);
415  fIsEmpty[i + j*fCellX] = kFALSE; // Makes the cell non-empty
416  continue;
417  }
418  // If a corner of the cell is inside the bin and since there is no
419  // intersection, then that cell completely inside the bin.
420  if((bin->IsInside(xclipl,yclipb)) || (bin->IsInside(xclipl,yclipt))){
421  fCells[i + j*fCellX].Add((TObject*) bin);
422  fIsEmpty[i + j*fCellX] = kFALSE; // Makes the cell non-empty
423  fCompletelyInside[i + fCellX*j] = kTRUE;
424  continue;
425  }
426  if((bin->IsInside(xclipr,yclipb)) || (bin->IsInside(xclipr,yclipt))){
427  fCells[i + j*fCellX].Add((TObject*) bin);
428  fIsEmpty[i + j*fCellX] = kFALSE; // Makes the cell non-empty
429  fCompletelyInside[i + fCellX*j] = kTRUE;
430  continue;
431  }
432  }
433  }
434 }
435 
436 ////////////////////////////////////////////////////////////////////////////////
437 /// Changes the number of partition cells in the histogram.
438 /// Deletes the old partition and constructs a new one.
439 
441 {
442  fCellX = n; // Set the number of cells
443  fCellY = m; // Set the number of cells
444 
445  delete [] fCells; // Deletes the old partition
446 
447  // number of cells in the grid
448  //N.B. not to be confused with fNcells (the number of bins) !
450  fCells = new TList [fNCells]; // Sets an empty partition
451 
454 
455  delete [] fIsEmpty;
456  delete [] fCompletelyInside;
457  fIsEmpty = new Bool_t [fNCells];
459 
460  // Initializes the flags
461  for (int i = 0; i<fNCells; i++) {
462  fIsEmpty[i] = kTRUE;
464  }
465 
466  // TList iterator
467  TIter next(fBins);
468  TObject *obj;
469 
470  while((obj = next())){ // Loop over bins and add them to the partition
472  }
473 }
474 
475 ////////////////////////////////////////////////////////////////////////////////
476 /// Make a complete copy of the underlying object. If 'newname' is set,
477 /// the copy's name will be set to that name.
478 
479 TObject* TH2Poly::Clone(const char* newname) const
480 {
481  // TH1::Clone relies on ::Copy to implemented by the derived class.
482  // Until this is implemented, revert to the much slower default version
483  // (and possibly non-thread safe).
484 
485  return TNamed::Clone(newname);
486 }
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 /// Clears the contents of all bins in the histogram.
490 
492 {
493  TIter next(fBins);
494  TObject *obj;
495  TH2PolyBin *bin;
496 
497  // Clears the bin contents
498  while ((obj = next())) {
499  bin = (TH2PolyBin*) obj;
500  bin->ClearContent();
501  }
502 
503  // Clears the statistics
504  fTsumw = 0;
505  fTsumw2 = 0;
506  fTsumwx = 0;
507  fTsumwx2 = 0;
508  fTsumwy = 0;
509  fTsumwy2 = 0;
510  fEntries = 0;
511 }
512 
513 ////////////////////////////////////////////////////////////////////////////////
514 /// Reset this histogram: contents, errors, etc.
515 
517 {
518  TIter next(fBins);
519  TObject *obj;
520  TH2PolyBin *bin;
521 
522  // Clears the bin contents
523  while ((obj = next())) {
524  bin = (TH2PolyBin*) obj;
525  bin->ClearContent();
526  }
527 
528  TH2::Reset(opt);
529 }
530 
531 ////////////////////////////////////////////////////////////////////////////////
532 /// Returns the bin number of the bin at the given coordinate. -1 to -9 are
533 /// the overflow and underflow bins. overflow bin -5 is the unbinned areas in
534 /// the histogram (also called "the sea"). The third parameter can be left
535 /// blank.
536 /// The overflow/underflow bins are:
537 ///~~~ {.cpp}
538 /// -1 | -2 | -3
539 /// -------------
540 /// -4 | -5 | -6
541 /// -------------
542 /// -7 | -8 | -9
543 ///~~~
544 /// where -5 means is the "sea" bin (i.e. unbinned areas)
545 
547 {
548 
549  // Checks for overflow/underflow
550  Int_t overflow = 0;
551  if (y > fYaxis.GetXmax()) overflow += -1;
552  else if (y > fYaxis.GetXmin()) overflow += -4;
553  else overflow += -7;
554  if (x > fXaxis.GetXmax()) overflow += -2;
555  else if (x > fXaxis.GetXmin()) overflow += -1;
556  if (overflow != -5) return overflow;
557 
558  // Finds the cell (x,y) coordinates belong to
559  Int_t n = (Int_t)(floor((x-fXaxis.GetXmin())/fStepX));
560  Int_t m = (Int_t)(floor((y-fYaxis.GetXmin())/fStepY));
561 
562  // Make sure the array indices are correct.
563  if (n>=fCellX) n = fCellX-1;
564  if (m>=fCellY) m = fCellY-1;
565  if (n<0) n = 0;
566  if (m<0) m = 0;
567 
568  if (fIsEmpty[n+fCellX*m]) return -5;
569 
570  TH2PolyBin *bin;
571 
572  TIter next(&fCells[n+fCellX*m]);
573  TObject *obj;
574 
575  // Search for the bin in the cell
576  while ((obj=next())) {
577  bin = (TH2PolyBin*)obj;
578  if (bin->IsInside(x,y)) return bin->GetBinNumber();
579  }
580 
581  // If the search has not returned a bin, the point must be on "the sea"
582  return -5;
583 }
584 
585 ////////////////////////////////////////////////////////////////////////////////
586 /// Increment the bin containing (x,y) by 1.
587 /// Uses the partitioning algorithm.
588 
590 {
591  return Fill(x, y, 1.0);
592 }
593 
594 ////////////////////////////////////////////////////////////////////////////////
595 /// Increment the bin containing (x,y) by w.
596 /// Uses the partitioning algorithm.
597 
599 {
600  // see GetBinCOntent for definition of overflow bins
601  // in case of weighted events store weight square in fSumw2.fArray
602  // but with this indexing:
603  // fSumw2.fArray[0:kNOverflow-1] : sum of weight squares for the overflow bins
604  // fSumw2.fArray[kNOverflow:fNcells] : sum of weight squares for the standard bins
605  // where fNcells = kNOverflow + Number of bins. kNOverflow=9
606 
607  if (fNcells <= kNOverflow) return 0;
608 
609  // create sum of weight square array if weights are different than 1
610  if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW) ) Sumw2();
611 
612  Int_t overflow = 0;
613  if (y > fYaxis.GetXmax()) overflow += -1;
614  else if (y > fYaxis.GetXmin()) overflow += -4;
615  else overflow += -7;
616  if (x > fXaxis.GetXmax()) overflow += -2;
617  else if(x > fXaxis.GetXmin()) overflow += -1;
618  if (overflow != -5) {
619  fOverflow[-overflow - 1]+= w;
620  if (fSumw2.fN) fSumw2.fArray[-overflow - 1] += w*w;
621  return overflow;
622  }
623 
624  // Finds the cell (x,y) coordinates belong to
625  Int_t n = (Int_t)(floor((x-fXaxis.GetXmin())/fStepX));
626  Int_t m = (Int_t)(floor((y-fYaxis.GetXmin())/fStepY));
627 
628  // Make sure the array indices are correct.
629  if (n>=fCellX) n = fCellX-1;
630  if (m>=fCellY) m = fCellY-1;
631  if (n<0) n = 0;
632  if (m<0) m = 0;
633 
634  if (fIsEmpty[n+fCellX*m]) {
635  fOverflow[4]+= w;
636  if (fSumw2.fN) fSumw2.fArray[4] += w*w;
637  return -5;
638  }
639 
640  TH2PolyBin *bin;
641  Int_t bi;
642 
643  TIter next(&fCells[n+fCellX*m]);
644  TObject *obj;
645 
646  while ((obj=next())) {
647  bin = (TH2PolyBin*)obj;
648  // needs to account offset in array for overflow bins
649  bi = bin->GetBinNumber()-1+kNOverflow;
650  if (bin->IsInside(x,y)) {
651  bin->Fill(w);
652 
653  // Statistics
654  fTsumw = fTsumw + w;
655  fTsumw2 = fTsumw2 + w*w;
656  fTsumwx = fTsumwx + w*x;
657  fTsumwx2 = fTsumwx2 + w*x*x;
658  fTsumwy = fTsumwy + w*y;
659  fTsumwy2 = fTsumwy2 + w*y*y;
660  if (fSumw2.fN) {
661  assert(bi < fSumw2.fN);
662  fSumw2.fArray[bi] += w*w;
663  }
664  fEntries++;
665 
667 
668  return bin->GetBinNumber();
669  }
670  }
671 
672  fOverflow[4]+= w;
673  if (fSumw2.fN) fSumw2.fArray[4] += w*w;
674  return -5;
675 }
676 
677 ////////////////////////////////////////////////////////////////////////////////
678 /// Increment the bin named "name" by w.
679 
681 {
682  TString sname(name);
683 
684  TIter next(fBins);
685  TObject *obj;
686  TH2PolyBin *bin;
687 
688  while ((obj = next())) {
689  bin = (TH2PolyBin*) obj;
690  if (!sname.CompareTo(bin->GetPolygon()->GetName())) {
691  bin->Fill(w);
692  fEntries++;
694  return bin->GetBinNumber();
695  }
696  }
697 
698  return 0;
699 }
700 
701 ////////////////////////////////////////////////////////////////////////////////
702 /// Fills a 2-D histogram with an array of values and weights.
703 ///
704 /// \param [in] ntimes: number of entries in arrays x and w
705 /// (array size must be ntimes*stride)
706 /// \param [in] x: array of x values to be histogrammed
707 /// \param [in] y: array of y values to be histogrammed
708 /// \param [in] w: array of weights
709 /// \param [in] stride: step size through arrays x, y and w
710 
711 void TH2Poly::FillN(Int_t ntimes, const Double_t* x, const Double_t* y,
712  const Double_t* w, Int_t stride)
713 {
714  for (int i = 0; i < ntimes; i += stride) {
715  Fill(x[i], y[i], w[i]);
716  }
717 }
718 
719 ////////////////////////////////////////////////////////////////////////////////
720 /// Returns the integral of bin contents.
721 /// By default the integral is computed as the sum of bin contents.
722 /// If option "width" or "area" is specified, the integral is the sum of
723 /// the bin contents multiplied by the area of the bin.
724 
726 {
727  TString opt = option;
728  opt.ToLower();
729 
730  if ((opt.Contains("width")) || (opt.Contains("area"))) {
731  Double_t w;
732  Double_t integral = 0.;
733 
734  TIter next(fBins);
735  TObject *obj;
736  TH2PolyBin *bin;
737  while ((obj=next())) {
738  bin = (TH2PolyBin*) obj;
739  w = bin->GetArea();
740  integral += w*(bin->GetContent());
741  }
742 
743  return integral;
744  } else {
745  return fTsumw;
746  }
747 }
748 
749 ////////////////////////////////////////////////////////////////////////////////
750 /// Returns the content of the input bin
751 /// For the overflow/underflow/sea bins:
752 ///~~~ {.cpp}
753 /// -1 | -2 | -3
754 /// ---+----+----
755 /// -4 | -5 | -6
756 /// ---+----+----
757 /// -7 | -8 | -9
758 ///~~~
759 /// where -5 is the "sea" bin (i.e. unbinned areas)
760 
762 {
763  if (bin > GetNumberOfBins() || bin == 0 || bin < -kNOverflow) return 0;
764  if (bin<0) return fOverflow[-bin - 1];
765  return ((TH2PolyBin*) fBins->At(bin-1))->GetContent();
766 }
767 
768 ////////////////////////////////////////////////////////////////////////////////
769 /// Returns the value of error associated to bin number bin.
770 /// If the sum of squares of weights has been defined (via Sumw2),
771 /// this function returns the sqrt(sum of w2).
772 /// otherwise it returns the sqrt(contents) for this bin.
773 /// Bins are in range [1:nbins] and for bin < 0 in range [-9:-1] it returns errors for overflow bins.
774 /// See also TH2Poly::GetBinContent
775 
777 {
778  if (bin == 0 || bin > GetNumberOfBins() || bin < - kNOverflow) return 0;
779  if (fBuffer) ((TH1*)this)->BufferEmpty();
780  // in case of weighted events the sum of the weights are stored in a different way than
781  // a normal histogram
782  // fSumw2.fArray[0:kNOverflow-1] : sum of weight squares for the overflow bins (
783  // fSumw2.fArray[kNOverflow:fNcells] : sum of weight squares for the standard bins
784  // fNcells = kNOverflow (9) + Number of bins
785  if (fSumw2.fN) {
786  Int_t binIndex = (bin > 0) ? bin+kNOverflow-1 : -(bin+1);
787  Double_t err2 = fSumw2.fArray[binIndex];
788  return TMath::Sqrt(err2);
789  }
790  Double_t error2 = TMath::Abs(GetBinContent(bin));
791  return TMath::Sqrt(error2);
792 }
793 
794 ////////////////////////////////////////////////////////////////////////////////
795 /// Set the bin Error.
796 /// Re-implementation for TH2Poly given the different bin indexing in the
797 /// stored squared error array.
798 /// See also notes in TH1::SetBinError
799 ///
800 /// Bins are in range [1:nbins] and for bin < 0 in the range [-9:-1] the errors is set for the overflow bins
801 
802 
804 {
805  if (bin == 0 || bin > GetNumberOfBins() || bin < - kNOverflow) return;
806  if (!fSumw2.fN) Sumw2();
808  // see comment in GetBinError for special convention of bin index in fSumw2 array
809  Int_t binIndex = (bin > 0) ? bin+kNOverflow-1 : -(bin+1);
810  fSumw2.fArray[binIndex] = error * error;
811 }
812 
813 
814 
815 ////////////////////////////////////////////////////////////////////////////////
816 /// Returns the bin name.
817 
818 const char *TH2Poly::GetBinName(Int_t bin) const
819 {
820  if (bin > GetNumberOfBins()) return "";
821  if (bin < 0) return "";
822  return ((TH2PolyBin*) fBins->At(bin-1))->GetPolygon()->GetName();
823 }
824 
825 ////////////////////////////////////////////////////////////////////////////////
826 /// Returns the bin title.
827 
828 const char *TH2Poly::GetBinTitle(Int_t bin) const
829 {
830  if (bin > GetNumberOfBins()) return "";
831  if (bin < 0) return "";
832  return ((TH2PolyBin*) fBins->At(bin-1))->GetPolygon()->GetTitle();
833 }
834 
835 ////////////////////////////////////////////////////////////////////////////////
836 /// Returns the maximum value of the histogram.
837 
839 {
840  if (fNcells <= kNOverflow) return 0;
841  if (fMaximum != -1111) return fMaximum;
842 
843  TH2PolyBin *b;
844 
845  TIter next(fBins);
846  TObject *obj;
847  Double_t max,c;
848 
849  max = ((TH2PolyBin*) next())->GetContent();
850 
851  while ((obj=next())) {
852  b = (TH2PolyBin*)obj;
853  c = b->GetContent();
854  if (c>max) max = c;
855  }
856  return max;
857 }
858 
859 ////////////////////////////////////////////////////////////////////////////////
860 /// Returns the maximum value of the histogram that is less than maxval.
861 
863 {
864  if (fNcells <= kNOverflow) return 0;
865  if (fMaximum != -1111) return fMaximum;
866 
867  TH2PolyBin *b;
868 
869  TIter next(fBins);
870  TObject *obj;
871  Double_t max,c;
872 
873  max = ((TH2PolyBin*) next())->GetContent();
874 
875  while ((obj=next())) {
876  b = (TH2PolyBin*)obj;
877  c = b->GetContent();
878  if (c>max && c<maxval) max=c;
879  }
880  return max;
881 }
882 
883 ////////////////////////////////////////////////////////////////////////////////
884 /// Returns the minimum value of the histogram.
885 
887 {
888  if (fNcells <= kNOverflow) return 0;
889  if (fMinimum != -1111) return fMinimum;
890 
891  TH2PolyBin *b;
892 
893  TIter next(fBins);
894  TObject *obj;
895  Double_t min,c;
896 
897  min = ((TH2PolyBin*) next())->GetContent();
898 
899  while ((obj=next())) {
900  b = (TH2PolyBin*)obj;
901  c = b->GetContent();
902  if (c<min) min=c;
903  }
904  return min;
905 }
906 
907 ////////////////////////////////////////////////////////////////////////////////
908 /// Returns the minimum value of the histogram that is greater than minval.
909 
911 {
912  if (fNcells <= kNOverflow) return 0;
913  if (fMinimum != -1111) return fMinimum;
914 
915  TH2PolyBin *b;
916 
917  TIter next(fBins);
918  TObject *obj;
919  Double_t min,c;
920 
921  min = ((TH2PolyBin*) next())->GetContent();
922 
923  while ((obj=next())) {
924  b = (TH2PolyBin*)obj;
925  c = b->GetContent();
926  if (c<min && c>minval) min=c;
927  }
928  return min;
929 }
930 
931 ////////////////////////////////////////////////////////////////////////////////
932 /// Bins the histogram using a honeycomb structure
933 
935  Int_t k, Int_t s)
936 {
937  // Add the bins
938  Double_t numberOfHexagonsInTheRow;
939  Double_t x[6], y[6];
940  Double_t xloop, yloop, xtemp;
941  xloop = xstart; yloop = ystart + a/2.0;
942  for (int sCounter = 0; sCounter < s; sCounter++) {
943 
944  xtemp = xloop; // Resets the temp variable
945 
946  // Determine the number of hexagons in that row
947  if(sCounter%2 == 0){numberOfHexagonsInTheRow = k;}
948  else{numberOfHexagonsInTheRow = k - 1;}
949 
950  for (int kCounter = 0; kCounter < numberOfHexagonsInTheRow; kCounter++) {
951 
952  // Go around the hexagon
953  x[0] = xtemp;
954  y[0] = yloop;
955  x[1] = x[0];
956  y[1] = y[0] + a;
957  x[2] = x[1] + a*TMath::Sqrt(3)/2.0;
958  y[2] = y[1] + a/2.0;
959  x[3] = x[2] + a*TMath::Sqrt(3)/2.0;
960  y[3] = y[1];
961  x[4] = x[3];
962  y[4] = y[0];
963  x[5] = x[2];
964  y[5] = y[4] - a/2.0;
965 
966  this->AddBin(6, x, y);
967 
968  // Go right
969  xtemp += a*TMath::Sqrt(3);
970  }
971 
972  // Increment the starting position
973  if (sCounter%2 == 0) xloop += a*TMath::Sqrt(3)/2.0;
974  else xloop -= a*TMath::Sqrt(3)/2.0;
975  yloop += 1.5*a;
976  }
977 }
978 
979 ////////////////////////////////////////////////////////////////////////////////
980 /// Initializes the TH2Poly object. This method is called by the constructor.
981 
983  Double_t ylow, Double_t yup, Int_t n, Int_t m)
984 {
985  Int_t i;
986  fDimension = 2; //The dimension of the histogram
987 
988  fBins = 0;
990 
991  // Sets the boundaries of the histogram
992  fXaxis.Set(100, xlow, xup);
993  fYaxis.Set(100, ylow, yup);
994 
995  for (i=0; i<9; i++) fOverflow[i] = 0.;
996 
997  // Statistics
998  fEntries = 0; // The total number of entries
999  fTsumw = 0.; // Total amount of content in the histogram
1000  fTsumw2 = 0.; // Sum square of the weights
1001  fTsumwx = 0.; // Weighted sum of x coordinates
1002  fTsumwx2 = 0.; // Weighted sum of the squares of x coordinates
1003  fTsumwy2 = 0.; // Weighted sum of the squares of y coordinates
1004  fTsumwy = 0.; // Weighted sum of y coordinates
1005 
1006  fCellX = n; // Set the number of cells to default
1007  fCellY = m; // Set the number of cells to default
1008 
1009  // number of cells in the grid
1010  //N.B. not to be confused with fNcells (the number of bins) !
1011  fNCells = fCellX*fCellY;
1012  fCells = new TList [fNCells]; // Sets an empty partition
1013  fStepX = (fXaxis.GetXmax() - fXaxis.GetXmin())/fCellX; // Cell width
1014  fStepY = (fYaxis.GetXmax() - fYaxis.GetXmin())/fCellY; // Cell height
1015 
1016  fIsEmpty = new Bool_t [fNCells]; // Empty partition
1017  fCompletelyInside = new Bool_t [fNCells]; // Cell is completely inside bin
1018 
1019  for (i = 0; i<fNCells; i++) { // Initializes the flags
1020  fIsEmpty[i] = kTRUE;
1022  }
1023 
1024  // 3D Painter flags
1027 }
1028 
1029 ////////////////////////////////////////////////////////////////////////////////
1030 /// Returns kTRUE if the input bin is intersecting with the
1031 /// input rectangle (xclipl, xclipr, yclipb, yclipt)
1032 
1034  Double_t xclipl, Double_t xclipr,
1035  Double_t yclipb, Double_t yclipt)
1036 {
1037  Int_t gn;
1038  Double_t *gx;
1039  Double_t *gy;
1040  Bool_t inter = kFALSE;
1041  TObject *poly = bin->GetPolygon();
1042 
1043  if (poly->IsA() == TGraph::Class()) {
1044  TGraph *g = (TGraph*)poly;
1045  gx = g->GetX();
1046  gy = g->GetY();
1047  gn = g->GetN();
1048  inter = IsIntersectingPolygon(gn, gx, gy, xclipl, xclipr, yclipb, yclipt);
1049  }
1050 
1051  if (poly->IsA() == TMultiGraph::Class()) {
1052  TMultiGraph *mg = (TMultiGraph*)poly;
1053  TList *gl = mg->GetListOfGraphs();
1054  if (!gl) return inter;
1055  TGraph *g;
1056  TIter next(gl);
1057  while ((g = (TGraph*) next())) {
1058  gx = g->GetX();
1059  gy = g->GetY();
1060  gn = g->GetN();
1061  inter = IsIntersectingPolygon(gn, gx, gy, xclipl, xclipr,
1062  yclipb, yclipt);
1063  if (inter) return inter;
1064  }
1065  }
1066 
1067  return inter;
1068 }
1069 
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// Returns kTRUE if the input polygon (bn, x, y) is intersecting with the
1072 /// input rectangle (xclipl, xclipr, yclipb, yclipt)
1073 
1075  Double_t xclipl, Double_t xclipr,
1076  Double_t yclipb, Double_t yclipt)
1077 {
1078  Bool_t p0R, p0L, p0T, p0B, p0xM, p0yM, p1R, p1L, p1T;
1079  Bool_t p1B, p1xM, p1yM, p0In, p1In;
1080 
1081  for (int counter = 0; counter < (bn-1); counter++) {
1082  // If both are on the same side, return kFALSE
1083  p0L = x[counter] <= xclipl; // Point 0 is on the left
1084  p1L = x[counter + 1] <= xclipl; // Point 1 is on the left
1085  if (p0L && p1L) continue;
1086  p0R = x[counter] >= xclipr; // Point 0 is on the right
1087  p1R = x[counter + 1] >= xclipr; // Point 1 is on the right
1088  if (p0R && p1R) continue;
1089  p0T = y[counter] >= yclipt; // Point 0 is at the top
1090  p1T = y[counter + 1] >= yclipt; // Point 1 is at the top
1091  if (p0T && p1T) continue;
1092  p0B = y[counter] <= yclipb; // Point 0 is at the bottom
1093  p1B = y[counter + 1] <= yclipb; // Point 1 is at the bottom
1094  if (p0B && p1B) continue;
1095 
1096  // Checks to see if any are inside
1097  p0xM = !p0R && !p0L; // Point 0 is inside along x
1098  p0yM = !p0T && !p0B; // Point 1 is inside along x
1099  p1xM = !p1R && !p1L; // Point 0 is inside along y
1100  p1yM = !p1T && !p1B; // Point 1 is inside along y
1101  p0In = p0xM && p0yM; // Point 0 is inside
1102  p1In = p1xM && p1yM; // Point 1 is inside
1103  if (p0In) {
1104  if (p1In) continue;
1105  return kTRUE;
1106  } else {
1107  if (p1In) return kTRUE;
1108  }
1109 
1110  // We know by now that the points are not in the same side and not inside.
1111 
1112  // Checks to see if they are opposite
1113 
1114  if (p0xM && p1xM) return kTRUE;
1115  if (p0yM && p1yM) return kTRUE;
1116 
1117  // We now know that the points are in different x and y indices
1118 
1119  Double_t xcoord[3], ycoord[3];
1120  xcoord[0] = x[counter];
1121  xcoord[1] = x[counter + 1];
1122  ycoord[0] = y[counter];
1123  ycoord[1] = y[counter + 1];
1124 
1125  if (p0L) {
1126  if(p1T){
1127  xcoord[2] = xclipl;
1128  ycoord[2] = yclipb;
1129  if((TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord)) ||
1130  (TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord))) continue;
1131  else return kTRUE;
1132  } else if (p1B) {
1133  xcoord[2] = xclipl;
1134  ycoord[2] = yclipt;
1135  if((TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) ||
1136  (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord))) continue;
1137  else return kTRUE;
1138  } else { // p1yM
1139  if (p0T) {
1140  xcoord[2] = xclipl;
1141  ycoord[2] = yclipb;
1142  if (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord)) continue;
1143  else return kTRUE;
1144  }
1145  if (p0B) {
1146  xcoord[2] = xclipl;
1147  ycoord[2] = yclipt;
1148  if (TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord)) continue;
1149  else return kTRUE;
1150  }
1151  }
1152  } else if (p0R) {
1153  if (p1T) {
1154  xcoord[2] = xclipl;
1155  ycoord[2] = yclipb;
1156  if ((TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord)) ||
1157  (TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord))) continue;
1158  else return kTRUE;
1159  } else if (p1B) {
1160  xcoord[2] = xclipl;
1161  ycoord[2] = yclipt;
1162  if ((TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) ||
1163  (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord))) continue;
1164  else return kTRUE;
1165  } else{ // p1yM
1166  if (p0T) {
1167  xcoord[2] = xclipr;
1168  ycoord[2] = yclipb;
1169  if (TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord)) continue;
1170  else return kTRUE;
1171  }
1172  if (p0B) {
1173  xcoord[2] = xclipr;
1174  ycoord[2] = yclipt;
1175  if (TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) continue;
1176  else return kTRUE;
1177  }
1178  }
1179  }
1180  }
1181  return kFALSE;
1182 }
1183 
1184 ////////////////////////////////////////////////////////////////////////////////
1185 /// Merge TH2Polys
1186 /// Given the special nature of the TH2Poly, the merge is implemented in
1187 /// terms of subsequent TH2Poly::Add calls.
1189 {
1190  for (auto h2pAsObj : *coll) {
1191  if (!Add((TH1*)h2pAsObj, 1.)) {
1192  Warning("Merge", "An issue was encountered during the merge operation.");
1193  return 0L;
1194  }
1195  }
1196  return GetEntries();
1197 }
1198 
1199 ////////////////////////////////////////////////////////////////////////////////
1200 /// Save primitive as a C++ statement(s) on output stream out
1201 
1202 void TH2Poly::SavePrimitive(std::ostream &out, Option_t *option)
1203 {
1204  out <<" "<<std::endl;
1205  out <<" "<< ClassName() <<" *";
1206 
1207  //histogram pointer has by default the histogram name.
1208  //however, in case histogram has no directory, it is safer to add a
1209  //incremental suffix
1210  static Int_t hcounter = 0;
1211  TString histName = GetName();
1212  if (!fDirectory && !histName.Contains("Graph")) {
1213  hcounter++;
1214  histName += "__";
1215  histName += hcounter;
1216  }
1217  const char *hname = histName.Data();
1218 
1219  //Construct the class initialization
1220  out << hname << " = new " << ClassName() << "(\"" << hname << "\", \""
1221  << GetTitle() << "\", " << fCellX << ", " << fXaxis.GetXmin()
1222  << ", " << fXaxis.GetXmax()
1223  << ", " << fCellY << ", " << fYaxis.GetXmin() << ", "
1224  << fYaxis.GetXmax() << ");" << std::endl;
1225 
1226  // Save Bins
1227  TIter next(fBins);
1228  TObject *obj;
1229  TH2PolyBin *th2pBin;
1230 
1231  while((obj = next())){
1232  th2pBin = (TH2PolyBin*) obj;
1233  th2pBin->GetPolygon()->SavePrimitive(out,
1234  TString::Format("th2poly%s",histName.Data()));
1235  }
1236 
1237  // save bin contents
1238  out<<" "<<std::endl;
1239  Int_t bin;
1240  for (bin=1;bin<=GetNumberOfBins();bin++) {
1241  Double_t bc = GetBinContent(bin);
1242  if (bc) {
1243  out<<" "<<hname<<"->SetBinContent("<<bin<<","<<bc<<");"<<std::endl;
1244  }
1245  }
1246 
1247  // save bin errors
1248  if (fSumw2.fN) {
1249  for (bin=1;bin<=GetNumberOfBins();bin++) {
1250  Double_t be = GetBinError(bin);
1251  if (be) {
1252  out<<" "<<hname<<"->SetBinError("<<bin<<","<<be<<");"<<std::endl;
1253  }
1254  }
1255  }
1256  TH1::SavePrimitiveHelp(out, hname, option);
1257 }
1258 
1259 ////////////////////////////////////////////////////////////////////////////////
1260 /// Multiply this histogram by a constant c1.
1261 
1263 {
1264  for( int i = 0; i < this->GetNumberOfBins(); i++ ) {
1265  this->SetBinContent(i+1, c1*this->GetBinContent(i+1));
1266  }
1267  for( int i = 0; i < kNOverflow; i++ ) {
1268  this->SetBinContent(-i-1, c1*this->GetBinContent(-i-1) );
1269  }
1270 }
1271 
1272 ////////////////////////////////////////////////////////////////////////////////
1273 /// Sets the contents of the input bin to the input content
1274 /// Negative values between -1 and -9 are for the overflows and the sea
1275 
1277 {
1278  if (bin > GetNumberOfBins() || bin == 0 || bin < -9 ) return;
1279  if (bin > 0) {
1280  ((TH2PolyBin*) fBins->At(bin-1))->SetContent(content);
1281  }
1282  else
1283  fOverflow[-bin - 1] = content;
1284 
1286  fEntries++;
1287 }
1288 
1289 ////////////////////////////////////////////////////////////////////////////////
1290 /// When set to kTRUE, allows the histogram to expand if a bin outside the
1291 /// limits is added.
1292 
1294 {
1295  fFloat = flag;
1296 }
1297 
1298 ////////////////////////////////////////////////////////////////////////////////
1299 /// Return "true" if the point (x,y) is inside the bin of binnr.
1300 
1302 {
1303  if (!fBins) return false;
1304  TH2PolyBin* bin = (TH2PolyBin*)fBins->At(binnr);
1305  if (!bin) return false;
1306  return bin->IsInside(x,y);
1307 }
1308 
1309 void TH2Poly::GetStats(Double_t *stats) const
1310 {
1311  stats[0] = fTsumw;
1312  stats[1] = fTsumw2;
1313  stats[2] = fTsumwx;
1314  stats[3] = fTsumwx2;
1315  stats[4] = fTsumwy;
1316  stats[5] = fTsumwy2;
1317  stats[6] = fTsumwxy;
1318 }
1319 
1320 /** \class TH2PolyBin
1321  \ingroup Hist
1322 Helper class to represent a bin in the TH2Poly histogram
1323 */
1324 
1325 ////////////////////////////////////////////////////////////////////////////////
1326 /// Default constructor.
1327 
1329 {
1330  fPoly = 0;
1331  fContent = 0.;
1332  fNumber = 0;
1333  fXmax = -1111;
1334  fXmin = -1111;
1335  fYmax = -1111;
1336  fYmin = -1111;
1337  fArea = 0;
1338  SetChanged(kTRUE);
1339 }
1340 
1341 ////////////////////////////////////////////////////////////////////////////////
1342 /// Normal constructor.
1343 
1345 {
1346  fContent = 0.;
1347  fNumber = bin_number;
1348  fArea = 0.;
1349  fPoly = poly;
1350  fXmax = -1111;
1351  fXmin = -1111;
1352  fYmax = -1111;
1353  fYmin = -1111;
1354  SetChanged(kTRUE);
1355 }
1356 
1357 ////////////////////////////////////////////////////////////////////////////////
1358 /// Destructor.
1359 
1361 {
1362  if (fPoly) delete fPoly;
1363 }
1364 
1365 ////////////////////////////////////////////////////////////////////////////////
1366 /// Returns the area of the bin.
1367 
1369 {
1370  Int_t bn;
1371 
1372  if (fArea == 0) {
1373  if (fPoly->IsA() == TGraph::Class()) {
1374  TGraph *g = (TGraph*)fPoly;
1375  bn = g->GetN();
1376  fArea = g->Integral(0,bn-1);
1377  }
1378 
1379  if (fPoly->IsA() == TMultiGraph::Class()) {
1381  TList *gl = mg->GetListOfGraphs();
1382  if (!gl) return fArea;
1383  TGraph *g;
1384  TIter next(gl);
1385  while ((g = (TGraph*) next())) {
1386  bn = g->GetN();
1387  fArea = fArea + g->Integral(0,bn-1);
1388  }
1389  }
1390  }
1391 
1392  return fArea;
1393 }
1394 
1395 ////////////////////////////////////////////////////////////////////////////////
1396 /// Returns the maximum value for the x coordinates of the bin.
1397 
1399 {
1400  if (fXmax != -1111) return fXmax;
1401 
1402  Int_t bn,i;
1403  Double_t *bx;
1404 
1405  if (fPoly->IsA() == TGraph::Class()) {
1406  TGraph *g = (TGraph*)fPoly;
1407  bx = g->GetX();
1408  bn = g->GetN();
1409  fXmax = bx[0];
1410  for (i=1; i<bn; i++) {if (fXmax < bx[i]) fXmax = bx[i];}
1411  }
1412 
1413  if (fPoly->IsA() == TMultiGraph::Class()) {
1415  TList *gl = mg->GetListOfGraphs();
1416  if (!gl) return fXmax;
1417  TGraph *g;
1418  TIter next(gl);
1419  Bool_t first = kTRUE;
1420  while ((g = (TGraph*) next())) {
1421  bx = g->GetX();
1422  bn = g->GetN();
1423  if (first) {fXmax = bx[0]; first = kFALSE;}
1424  for (i=0; i<bn; i++) {if (fXmax < bx[i]) fXmax = bx[i];}
1425  }
1426  }
1427 
1428  return fXmax;
1429 }
1430 
1431 ////////////////////////////////////////////////////////////////////////////////
1432 /// Returns the minimum value for the x coordinates of the bin.
1433 
1435 {
1436  if (fXmin != -1111) return fXmin;
1437 
1438  Int_t bn,i;
1439  Double_t *bx;
1440 
1441  if (fPoly->IsA() == TGraph::Class()) {
1442  TGraph *g = (TGraph*)fPoly;
1443  bx = g->GetX();
1444  bn = g->GetN();
1445  fXmin = bx[0];
1446  for (i=1; i<bn; i++) {if (fXmin > bx[i]) fXmin = bx[i];}
1447  }
1448 
1449  if (fPoly->IsA() == TMultiGraph::Class()) {
1451  TList *gl = mg->GetListOfGraphs();
1452  if (!gl) return fXmin;
1453  TGraph *g;
1454  TIter next(gl);
1455  Bool_t first = kTRUE;
1456  while ((g = (TGraph*) next())) {
1457  bx = g->GetX();
1458  bn = g->GetN();
1459  if (first) {fXmin = bx[0]; first = kFALSE;}
1460  for (i=0; i<bn; i++) {if (fXmin > bx[i]) fXmin = bx[i];}
1461  }
1462  }
1463 
1464  return fXmin;
1465 }
1466 
1467 ////////////////////////////////////////////////////////////////////////////////
1468 /// Returns the maximum value for the y coordinates of the bin.
1469 
1471 {
1472  if (fYmax != -1111) return fYmax;
1473 
1474  Int_t bn,i;
1475  Double_t *by;
1476 
1477  if (fPoly->IsA() == TGraph::Class()) {
1478  TGraph *g = (TGraph*)fPoly;
1479  by = g->GetY();
1480  bn = g->GetN();
1481  fYmax = by[0];
1482  for (i=1; i<bn; i++) {if (fYmax < by[i]) fYmax = by[i];}
1483  }
1484 
1485  if (fPoly->IsA() == TMultiGraph::Class()) {
1487  TList *gl = mg->GetListOfGraphs();
1488  if (!gl) return fYmax;
1489  TGraph *g;
1490  TIter next(gl);
1491  Bool_t first = kTRUE;
1492  while ((g = (TGraph*) next())) {
1493  by = g->GetY();
1494  bn = g->GetN();
1495  if (first) {fYmax = by[0]; first = kFALSE;}
1496  for (i=0; i<bn; i++) {if (fYmax < by[i]) fYmax = by[i];}
1497  }
1498  }
1499 
1500  return fYmax;
1501 }
1502 
1503 ////////////////////////////////////////////////////////////////////////////////
1504 /// Returns the minimum value for the y coordinates of the bin.
1505 
1507 {
1508  if (fYmin != -1111) return fYmin;
1509 
1510  Int_t bn,i;
1511  Double_t *by;
1512 
1513  if (fPoly->IsA() == TGraph::Class()) {
1514  TGraph *g = (TGraph*)fPoly;
1515  by = g->GetY();
1516  bn = g->GetN();
1517  fYmin = by[0];
1518  for (i=1; i<bn; i++) {if (fYmin > by[i]) fYmin = by[i];}
1519  }
1520 
1521  if (fPoly->IsA() == TMultiGraph::Class()) {
1523  TList *gl = mg->GetListOfGraphs();
1524  if (!gl) return fYmin;
1525  TGraph *g;
1526  TIter next(gl);
1527  Bool_t first = kTRUE;
1528  while ((g = (TGraph*) next())) {
1529  by = g->GetY();
1530  bn = g->GetN();
1531  if (first) {fYmin = by[0]; first = kFALSE;}
1532  for (i=0; i<bn; i++) {if (fYmin > by[i]) fYmin = by[i];}
1533  }
1534  }
1535 
1536  return fYmin;
1537 }
1538 
1539 ////////////////////////////////////////////////////////////////////////////////
1540 /// Return "true" if the point (x,y) is inside the bin.
1541 
1543 {
1544  Int_t in=0;
1545 
1546  if (fPoly->IsA() == TGraph::Class()) {
1547  TGraph *g = (TGraph*)fPoly;
1548  in = g->IsInside(x, y);
1549  }
1550 
1551  if (fPoly->IsA() == TMultiGraph::Class()) {
1553  in = mg->IsInside(x, y);
1554  }
1555 
1556  return in;
1557 }
1558 
1559 ////////////////////////////////////////////////////////////////////////
1560 /// RE-implement dummy functions to avoid users calling the
1561 /// corresponding implemntations in TH1 or TH2
1562 //////////////////////////////////////////////////////////////////////////
1563 
1564 ////////////////////////////////////////////////////////////////////////////////
1565 /// Performs the operation: this = this + c1*f1. NOT IMPLEMENTED for TH2Poly
1567 {
1568  Error("Add","Not implement for TH2Poly");
1569  return kFALSE;
1570 }
1571 
1572 ////////////////////////////////////////////////////////////////////////////////
1573 /// Replace contents of this histogram by the addition of h1 and h2. NOT IMPLEMENTED for TH2Poly
1575 {
1576  Error("Add","Not implement for TH2Poly");
1577  return kFALSE;
1578 }
1579 
1580 ////////////////////////////////////////////////////////////////////////////////
1581 /// Performs the operation: this = this / c1*f1. NOT IMPLEMENTED for TH2Poly
1583 {
1584  Error("Divide","Not implement for TH2Poly");
1585  return kFALSE;
1586 }
1587 
1588 ////////////////////////////////////////////////////////////////////////////////
1589 /// NOT IMPLEMENTED for TH2Poly
1591 {
1592  Error("Multiply","Not implement for TH2Poly");
1593  return kFALSE;
1594 }
1595 ////////////////////////////////////////////////////////////////////////////////
1596 /// NOT IMPLEMENTED for TH2Poly
1598 {
1599  Error("ComputeIntegral","Not implement for TH2Poly");
1600  return TMath::QuietNaN();
1601 }
1602 ////////////////////////////////////////////////////////////////////////////////
1603 /// NOT IMPLEMENTED for TH2Poly
1605 {
1606  Error("FFT","Not implement for TH2Poly");
1607  return nullptr;
1608 }
1609 ////////////////////////////////////////////////////////////////////////////////
1610 /// NOT IMPLEMENTED for TH2Poly
1612 {
1613  Error("GetAsymmetry","Not implement for TH2Poly");
1614  return nullptr;
1615 }
1616 ////////////////////////////////////////////////////////////////////////////////
1617 /// NOT IMPLEMENTED for TH2Poly
1619 {
1620  Error("Interpolate","Not implement for TH2Poly");
1621  return TMath::QuietNaN();
1622 }
TGeant4Unit::mg
static constexpr double mg
Definition: TGeant4SystemOfUnits.h:204
c
#define c(i)
Definition: RSha256.hxx:101
m
auto * m
Definition: textangle.C:8
n
const Int_t n
Definition: legend1.C:16
TH1::GetSumw2N
virtual Int_t GetSumw2N() const
Definition: TH1.h:314
first
Definition: first.py:1
TObject::SavePrimitive
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:666
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TH2Poly::IsIntersectingPolygon
Bool_t IsIntersectingPolygon(Int_t bn, Double_t *x, Double_t *y, Double_t xclipl, Double_t xclipr, Double_t yclipb, Double_t yclipt)
Returns kTRUE if the input polygon (bn, x, y) is intersecting with the input rectangle (xclipl,...
Definition: TH2Poly.cxx:1074
TH2Poly::SetBinContent
virtual void SetBinContent(Int_t bin, Double_t content)
Sets the contents of the input bin to the input content Negative values between -1 and -9 are for the...
Definition: TH2Poly.cxx:1276
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TH2PolyBin::GetYMin
Double_t GetYMin()
Returns the minimum value for the y coordinates of the bin.
Definition: TH2Poly.cxx:1506
TH2Poly::AddBin
virtual Int_t AddBin(TObject *poly)
Adds a new bin to the histogram.
Definition: TH2Poly.cxx:222
TH1::fYaxis
TAxis fYaxis
Y axis descriptor.
Definition: TH1.h:90
TH2Poly::Scale
virtual void Scale(Double_t c1=1, Option_t *option="")
Multiply this histogram by a constant c1.
Definition: TH2Poly.cxx:1262
TAxis::Set
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition: TAxis.cxx:731
Option_t
const char Option_t
Definition: RtypesCore.h:66
TH2PolyBin::fXmin
Double_t fXmin
X minimum value.
Definition: TH2Poly.h:53
TH2::fTsumwy2
Double_t fTsumwy2
Definition: TH2.h:35
TH2Poly::GetNumberOfBins
Int_t GetNumberOfBins() const
Definition: TH2Poly.h:110
TMath::QuietNaN
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754
Definition: TMath.h:901
TH2Poly::Add
virtual Bool_t Add(const TH1 *h1, Double_t c1)
Performs the operation: this = this + c1*h1.
Definition: TH2Poly.cxx:290
TH2Poly::SetBinContentChanged
void SetBinContentChanged(Bool_t flag)
Definition: TH2Poly.h:119
TH2PolyBin::fPoly
TObject * fPoly
Object holding the polygon definition.
Definition: TH2Poly.h:50
floor
double floor(double)
TH2PolyBin::fNumber
Int_t fNumber
Bin number of the bin in TH2Poly.
Definition: TH2Poly.h:49
TH1::fEntries
Double_t fEntries
Number of entries.
Definition: TH1.h:94
TH2Poly::Divide
virtual Bool_t Divide(TF1 *, Double_t)
Performs the operation: this = this / c1*f1. NOT IMPLEMENTED for TH2Poly.
Definition: TH2Poly.cxx:1582
TH2Poly::ComputeIntegral
virtual Double_t ComputeIntegral(Bool_t)
NOT IMPLEMENTED for TH2Poly.
Definition: TH2Poly.cxx:1597
TString::Data
const char * Data() const
Definition: TString.h:369
TH2::Integral
virtual Double_t Integral(Option_t *option="") const
Return integral of bin contents.
Definition: TH1.cxx:7760
TH2PolyBin::fArea
Double_t fArea
Bin area.
Definition: TH2Poly.h:51
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
TH2Poly::kNOverflow
@ kNOverflow
Definition: TH2Poly.h:154
TH2::PutStats
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
Definition: TH2.cxx:2376
TH1::fTsumw
Double_t fTsumw
Total Sum of weights.
Definition: TH1.h:95
TGraph.h
TH1::SetContent
virtual void SetContent(const Double_t *content)
Replace bin contents by the contents of array content.
Definition: TH1.cxx:8172
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TH2PolyBin::~TH2PolyBin
virtual ~TH2PolyBin()
Destructor.
Definition: TH2Poly.cxx:1360
TH2Poly::Clone
TObject * Clone(const char *newname="") const
Make a complete copy of the underlying object.
Definition: TH2Poly.cxx:479
TH2Poly::fCellX
Int_t fCellX
Number of partition cells in the x-direction of the histogram.
Definition: TH2Poly.h:157
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
TH2Poly::GetBins
TList * GetBins()
Returns the TList of all bins in the histogram.
Definition: TH2Poly.h:98
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
TH2PolyBin::GetContent
Double_t GetContent() const
Definition: TH2Poly.h:35
TH1::kIsNotW
@ kIsNotW
Histogram is forced to be not weighted even when the histogram is filled with weighted different than...
Definition: TH1.h:171
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:162
TH2Poly::GetMinimum
Double_t GetMinimum() const
Returns the minimum value of the histogram.
Definition: TH2Poly.cxx:886
Int_t
int Int_t
Definition: RtypesCore.h:45
TH1::fDirectory
TDirectory * fDirectory
!Pointer to directory holding this histogram
Definition: TH1.h:108
TH1::fBuffer
Double_t * fBuffer
[fBufferSize] entry buffer
Definition: TH1.h:107
TH1::GetEntries
virtual Double_t GetEntries() const
Return the current number of entries.
Definition: TH1.cxx:4363
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
x
Double_t x[n]
Definition: legend1.C:17
TH2Poly::fCells
TList * fCells
[fNCells] The array of TLists that store the bins that intersect with each cell. List do not own the ...
Definition: TH2Poly.h:160
TList.h
TH2PolyBin::fContent
Double_t fContent
Bin content.
Definition: TH2Poly.h:52
TH2Poly::Merge
Long64_t Merge(TCollection *)
Merge TH2Polys Given the special nature of the TH2Poly, the merge is implemented in terms of subseque...
Definition: TH2Poly.cxx:1188
TH2Poly::ClearBinContents
void ClearBinContents()
Clears the contents of all bins in the histogram.
Definition: TH2Poly.cxx:491
TH2Poly::GetBinTitle
const char * GetBinTitle(Int_t bin) const
Returns the bin title.
Definition: TH2Poly.cxx:828
TH2Poly::fNCells
Int_t fNCells
Number of partition cells: fCellX*fCellY.
Definition: TH2Poly.h:159
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TH2PolyBin::fYmax
Double_t fYmax
Y maximum value.
Definition: TH2Poly.h:56
TH1::fNcells
Int_t fNcells
number of bins(1D), cells (2D) +U/Overflows
Definition: TH1.h:88
TArray::fN
Int_t fN
Definition: TArray.h:38
TString::Format
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:2311
TH1::SetName
virtual void SetName(const char *name)
Change the name of this histogram.
Definition: TH1.cxx:8726
TH1::fDimension
Int_t fDimension
!Histogram dimension (1, 2 or 3 dim)
Definition: TH1.h:109
TH1::ResetStats
virtual void ResetStats()
Reset the statistics including the number of entries and replace with values calculated from bin cont...
Definition: TH1.cxx:7721
TH1::fMaximum
Double_t fMaximum
Maximum value for plotting.
Definition: TH1.h:99
TString
Basic string class.
Definition: TString.h:136
TMath::IsInside
Bool_t IsInside(T xp, T yp, Int_t np, T *x, T *y)
Function which returns kTRUE if point xp,yp lies inside the polygon defined by the np points in array...
Definition: TMath.h:1209
TH2Poly::GetBinContent
virtual Double_t GetBinContent(Int_t bin) const
Returns the content of the input bin For the overflow/underflow/sea bins:
Definition: TH2Poly.cxx:761
b
#define b(i)
Definition: RSha256.hxx:100
TH2Poly::FFT
virtual TH1 * FFT(TH1 *, Option_t *)
NOT IMPLEMENTED for TH2Poly.
Definition: TH2Poly.cxx:1604
h1
TH1F * h1
Definition: legend1.C:5
TH2::Reset
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition: TH2.cxx:2491
TH2Poly::fFloat
Bool_t fFloat
When set to kTRUE, allows the histogram to expand if a bin outside the limits is added.
Definition: TH2Poly.h:164
bool
TH1::fTsumw2
Double_t fTsumw2
Total Sum of squares of weights.
Definition: TH1.h:96
TH2Poly::FindBin
Int_t FindBin(Double_t x, Double_t y, Double_t z=0)
Returns the bin number of the bin at the given coordinate.
Definition: TH2Poly.cxx:546
TH2Poly::GetBinError
virtual Double_t GetBinError(Int_t bin) const
Returns the value of error associated to bin number bin.
Definition: TH2Poly.cxx:776
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TMultiGraph.h
TH1::GetNormFactor
virtual Double_t GetNormFactor() const
Definition: TH1.h:300
TH2PolyBin::fYmin
Double_t fYmin
Y minimum value.
Definition: TH2Poly.h:54
TH2Poly::fCompletelyInside
Bool_t * fCompletelyInside
[fNCells] The array that returns true if the cell at the given coordinate is completely inside a bin
Definition: TH2Poly.h:163
TH1::SetTitle
virtual void SetTitle(const char *title)
See GetStatOverflows for more information.
Definition: TH1.cxx:6655
TGeant4Unit::L
static constexpr double L
Definition: TGeant4SystemOfUnits.h:117
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TH2PolyBin::ClearContent
void ClearContent()
Definition: TH2Poly.h:32
TH2PolyBin::TH2PolyBin
TH2PolyBin()
Default constructor.
Definition: TH2Poly.cxx:1328
TH2Poly::GetBinName
const char * GetBinName(Int_t bin) const
Returns the bin name.
Definition: TH2Poly.cxx:818
TH2Poly::fStepX
Double_t fStepX
Definition: TH2Poly.h:161
TH2PolyBin
Helper class to represent a bin in the TH2Poly histogram.
Definition: TH2Poly.h:25
TH2Poly::CreateBin
virtual TH2PolyBin * CreateBin(TObject *poly)
Create appropriate histogram bin.
Definition: TH2Poly.cxx:200
TList::At
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition: TList.cxx:357
TH2::fTsumwxy
Double_t fTsumwxy
Definition: TH2.h:36
kCounter
@ kCounter
Definition: TDataType.h:34
TH1::SavePrimitiveHelp
virtual void SavePrimitiveHelp(std::ostream &out, const char *hname, Option_t *option="")
Helper function for the SavePrimitive functions from TH1 or classes derived from TH1,...
Definition: TH1.cxx:7241
TH2PolyBin::GetBinNumber
Int_t GetBinNumber() const
Definition: TH2Poly.h:37
TH2Poly::Interpolate
virtual Double_t Interpolate(Double_t x) const
illegal for a TH2
Definition: TH2.cxx:1251
TH2Poly::Initialize
void Initialize(Double_t xlow, Double_t xup, Double_t ylow, Double_t yup, Int_t n, Int_t m)
Initializes the TH2Poly object. This method is called by the constructor.
Definition: TH2Poly.cxx:982
TH2PolyBin::GetXMin
Double_t GetXMin()
Returns the minimum value for the x coordinates of the bin.
Definition: TH2Poly.cxx:1434
TH2Poly::SetBinError
virtual void SetBinError(Int_t bin, Double_t error)
Set the bin Error.
Definition: TH2Poly.cxx:803
TAxis::GetXmin
Double_t GetXmin() const
Definition: TAxis.h:133
TH2Poly::TH2Poly
TH2Poly()
Default Constructor. No boundaries specified.
Definition: TH2Poly.cxx:147
TH2PolyBin::GetArea
Double_t GetArea()
Returns the area of the bin.
Definition: TH2Poly.cxx:1368
TH2PolyBin::SetChanged
void SetChanged(Bool_t flag)
Definition: TH2Poly.h:44
TH2Poly::Reset
virtual void Reset(Option_t *option)
Reset this histogram: contents, errors, etc.
Definition: TH2Poly.cxx:516
TH2Poly::IsIntersecting
Bool_t IsIntersecting(TH2PolyBin *bin, Double_t xclipl, Double_t xclipr, Double_t yclipb, Double_t yclipt)
Returns kTRUE if the input bin is intersecting with the input rectangle (xclipl, xclipr,...
Definition: TH2Poly.cxx:1033
TH1::SetEntries
virtual void SetEntries(Double_t n)
Definition: TH1.h:385
TH2Poly::fOverflow
Double_t fOverflow[kNOverflow]
Overflow bins.
Definition: TH2Poly.h:156
TH2Poly::fBins
TList * fBins
List of bins. The list owns the contained objects.
Definition: TH2Poly.h:167
a
auto * a
Definition: textangle.C:12
TArrayD::Set
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TH2Poly::Multiply
virtual Bool_t Multiply(TF1 *, Double_t)
NOT IMPLEMENTED for TH2Poly.
Definition: TH2Poly.cxx:1590
s1
#define s1(x)
Definition: RSha256.hxx:91
TH2PolyBin::Fill
void Fill(Double_t w)
Definition: TH2Poly.h:33
TNamed::Clone
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TNamed.cxx:74
TH2Poly.h
TH2Poly::fStepY
Double_t fStepY
Dimensions of a partition cell.
Definition: TH2Poly.h:161
TH1::GetBinErrorSqUnchecked
virtual Double_t GetBinErrorSqUnchecked(Int_t bin) const
Definition: TH1.h:443
TH1::fMinimum
Double_t fMinimum
Minimum value for plotting.
Definition: TH1.h:100
TH2Poly::IsInsideBin
Bool_t IsInsideBin(Int_t binnr, Double_t x, Double_t y)
Return "true" if the point (x,y) is inside the bin of binnr.
Definition: TH2Poly.cxx:1301
y
Double_t y[n]
Definition: legend1.C:17
TH2Poly::GetStats
virtual void GetStats(Double_t *stats) const
Fill the array stats from the contents of this histogram The array stats must be correctly dimensione...
Definition: TH2Poly.cxx:1309
TH2Poly::fCellY
Int_t fCellY
Number of partition cells in the y-direction of the histogram.
Definition: TH2Poly.h:158
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:876
TH2Poly::SetNewBinAdded
void SetNewBinAdded(Bool_t flag)
Definition: TH2Poly.h:121
TH2Poly::GetMaximum
Double_t GetMaximum() const
Returns the maximum value of the histogram.
Definition: TH2Poly.cxx:838
TMultiGraph
A TMultiGraph is a collection of TGraph (or derived) objects.
Definition: TMultiGraph.h:36
TH2Poly::SetFloat
void SetFloat(Bool_t flag=true)
When set to kTRUE, allows the histogram to expand if a bin outside the limits is added.
Definition: TH2Poly.cxx:1293
TH2Poly::Honeycomb
void Honeycomb(Double_t xstart, Double_t ystart, Double_t a, Int_t k, Int_t s)
Bins the histogram using a honeycomb structure.
Definition: TH2Poly.cxx:934
TArrayD::fArray
Double_t * fArray
Definition: TArrayD.h:30
TH2Poly::GetAsymmetry
virtual TH1 * GetAsymmetry(TH1 *, Double_t, Double_t)
NOT IMPLEMENTED for TH2Poly.
Definition: TH2Poly.cxx:1611
TString::CompareTo
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Definition: TString.cxx:418
Double_t
double Double_t
Definition: RtypesCore.h:59
TGraph
A TGraph is an object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
TH1::GetStats
virtual void GetStats(Double_t *stats) const
fill the array stats from the contents of this histogram The array stats must be correctly dimensione...
Definition: TH1.cxx:7655
TH1::fSumw2
TArrayD fSumw2
Array of sum of squares of weights.
Definition: TH1.h:103
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TH1::Sumw2
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition: TH1.cxx:8786
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TH2Poly::fIsEmpty
Bool_t * fIsEmpty
[fNCells] The array that returns true if the cell at the given coordinate is empty
Definition: TH2Poly.h:162
TH1::fTsumwx2
Double_t fTsumwx2
Total Sum of weight*X*X.
Definition: TH1.h:98
TH1
TH1 is the base class of all histogramm classes in ROOT.
Definition: TH1.h:58
name
char name[80]
Definition: TGX11.cxx:110
TH2Poly::ChangePartition
void ChangePartition(Int_t n, Int_t m)
Changes the number of partition cells in the histogram.
Definition: TH2Poly.cxx:440
TH1::fXaxis
TAxis fXaxis
X axis descriptor.
Definition: TH1.h:89
TH2Poly::FillN
void FillN(Int_t ntimes, const Double_t *x, const Double_t *y, const Double_t *w, Int_t stride=1)
Fills a 2-D histogram with an array of values and weights.
Definition: TH2Poly.cxx:711
TH2PolyBin::GetPolygon
TObject * GetPolygon() const
Definition: TH2Poly.h:38
TH2Poly::Fill
virtual Int_t Fill(Double_t x, Double_t y)
Increment the bin containing (x,y) by 1.
Definition: TH2Poly.cxx:589
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
TIter
Definition: TCollection.h:233
TH2Poly::RetrieveBinContent
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: TH2Poly.h:174
TH2Poly
2D Histogram with Polygonal Bins
Definition: TH2Poly.h:66
TH2PolyBin::IsInside
Bool_t IsInside(Double_t x, Double_t y) const
Return "true" if the point (x,y) is inside the bin.
Definition: TH2Poly.cxx:1542
TCollection
Collection abstract base class.
Definition: TCollection.h:63
TH2PolyBin::GetXMax
Double_t GetXMax()
Returns the maximum value for the x coordinates of the bin.
Definition: TH2Poly.cxx:1398
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TH2PolyBin::fXmax
Double_t fXmax
X maximum value.
Definition: TH2Poly.h:55
TAxis::GetXmax
Double_t GetXmax() const
Definition: TAxis.h:134
TH2PolyBin::GetYMax
Double_t GetYMax()
Returns the maximum value for the y coordinates of the bin.
Definition: TH2Poly.cxx:1470
TF1
1-Dim function class
Definition: TF1.h:213
Class
void Class()
Definition: Class.C:29
TH1::GetSumOfWeights
virtual Double_t GetSumOfWeights() const
Return the sum of weights excluding under/overflows.
Definition: TH1.cxx:7736
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1125
TH2Poly::SavePrimitive
void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
Definition: TH2Poly.cxx:1202
TH1::fTsumwx
Double_t fTsumwx
Total Sum of weight*X.
Definition: TH1.h:97
TH2Poly::~TH2Poly
virtual ~TH2Poly()
Destructor.
Definition: TH2Poly.cxx:184
Riostream.h
TH1::kNormal
@ kNormal
errors with Normal (Wald) approximation: errorUp=errorLow= sqrt(N)
Definition: TH1.h:64
TH2::fTsumwy
Double_t fTsumwy
Definition: TH2.h:34
TObject::ClassName
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
TH2Poly::AddBinToPartition
void AddBinToPartition(TH2PolyBin *bin)
Adds the input bin into the partition cell matrix.
Definition: TH2Poly.cxx:368
TH1::kNstat
@ kNstat
Definition: TH1.h:183
TH2Poly::UpdateBinContent
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: TH2Poly.h:177
TList
A doubly linked list.
Definition: TList.h:44
TMath.h
int
TH1::SetBinErrorOption
virtual void SetBinErrorOption(EBinErrorOpt type)
Definition: TH1.h:376
c1
return c1
Definition: legend1.C:41
g
#define g(i)
Definition: RSha256.hxx:105