ROOT logo
// @(#)root/hist:$Id$
// TH2Poly v2.1
// Author: Olivier Couet, Deniz Gunceler

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#include "TROOT.h"
#include "TClass.h"
#include "TH2Poly.h"
#include "TCutG.h"
#include "TList.h"
#include "TMath.h"
#include "TMultiGraph.h"
#include "TGraph.h"
#include "TStyle.h"
#include "TCanvas.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "Riostream.h"

ClassImp(TH2Poly)

//______________________________________________________________________________
/* Begin_Html
<center><h2>TH2Poly: 2D Histogram with Polygonal Bins</h2></center>

<h3>Overview</h3>
<tt>TH2Poly</tt> is a 2D Histogram class (TH2) allowing to define polygonal
bins of arbitrary shape.
<p>
Each bin in the <tt>TH2Poly</tt> histogram is a <tt>TH2PolyBin</tt> object.
<tt>TH2PolyBin</tt> is a very simple class containing the vertices (stored
as <tt>TGraph</tt>s or <tt>TMultiGraph</tt>s ) and contents of the polygonal
bin as well as several related functions.
<p>
Essentially, a <tt>TH2Poly</tt> is a TList of <tt>TH2PolyBin</tt> objects
with methods to manipulate them.
<p>
Bins are defined using one of the <tt>AddBin()</tt> methods. The bin definition
should be done before filling.
<p>
The histogram can be filled with <tt>Fill(Double_t x, Double_t y, Double_t w)
</tt>. <tt>w</tt> is the weight.
If no weight is specified, it is assumed to be 1.
<p>
Not all histogram's area need to be binned. Filling an area without bins,
will falls into the overflows. Adding a bin is not retroactive; it doesn't
affect previous fillings. A <tt>Fill()</tt> call, that
was previously ignored due to the lack of a bin at the specified location, is
not reconsidered when that location is binned later.
<p>
If there are two overlapping bins, the first one in the list will be incremented
by <tt>Fill()</tt>.
<p>
The histogram may automatically extends its limits if a bin outside the
histogram limits is added. This is done when the default constructor (with no
arguments) is used. It generates a histogram with no limits along the X and Y
axis. Adding bins to it will extend it up to a proper size.
<p>
<tt>TH2Poly</tt> implements a partitioning algorithm to speed up bins' filling.
The partitioning algorithm divides the histogram into regions called cells.
The bins that each cell intersects are recorded in an array of <tt>TList</tt>s.
When a coordinate in the histogram is to be filled; the method (quickly) finds
which cell the coordinate belongs.  It then only loops over the bins
intersecting that cell to find the bin the input coordinate corresponds to.
The partitioning of the histogram is updated continuously as each bin is added.
The default number of cells on each axis is 25. This number could be set to
another value in the constructor or adjusted later by calling the
<tt>ChangePartition(Int_t, Int_t)</tt> method. The partitioning algorithm is
considerably faster than the brute force algorithm (i.e. checking if each bin
contains the input coordinates), especially if the histogram is to be filled
many times.
<p>
The following very simple macro shows how to build and fill a <tt>TH2Poly</tt>:
<pre>
{
    TH2Poly *h2p = new TH2Poly();

    Double_t x1[] = {0, 5, 6};
    Double_t y1[] = {0, 0, 5};
    Double_t x2[] = {0, -1, -1, 0};
    Double_t y2[] = {0, 0, -1, 3};
    Double_t x3[] = {4, 3, 0, 1, 2.4};
    Double_t y3[] = {4, 3.7, 1, 3.7, 2.5};

    h2p->AddBin(3, x1, y1);
    h2p->AddBin(4, x2, y2);
    h2p->AddBin(5, x3, y3);

    h2p->Fill(0.1, 0.01, 3);
    h2p->Fill(-0.5, -0.5, 7);
    h2p->Fill(-0.7, -0.5, 1);
    h2p->Fill(1, 3, 1.5);
}
</pre>
<p>
More examples can bin found in <tt>$ROOTSYS/tutorials/hist/th2poly*.C</tt>

<h3>Partitioning Algorithm</h3>
The partitioning algorithm forms an essential part of the <tt>TH2Poly</tt>
class. It is implemented to speed up the filling of bins.
<p>
With the brute force approach, the filling is done in the following way:  An
iterator loops over all bins in the <tt>TH2Poly</tt> and invokes the
method <tt>IsInside()</tt> for each of them.
This method checks if the input location is in that bin. If the filling
coordinate is inside, the bin is filled. Looping over all the bin is
very slow.
<p>
The alternative is to divide the histogram into virtual rectangular regions
called "cells". Each cell stores the pointers of the bins intersecting it.
When a coordinate is to be filled, the method finds which cell the coordinate
falls into. Since the cells are rectangular, this can be done very quickly.
It then only loops over the bins associated with that cell.
<p>
The addition of bins to the appropriate cells is done when the bin is added
to the histogram. To do this, <tt>AddBin()</tt> calls the
<tt>AddBinToPartition()</tt> method.
This method adds the input bin to the partitioning matrix.
<p>
The number of partition cells per axis can be specified in the constructor.
If it is not specified, the default value of 25 along each axis will be
assigned. This value was chosen because it is small enough to avoid slowing
down AddBin(), while being large enough to enhance Fill() by a considerable
amount. Regardless of how it is initialized at construction time, it can be
changed later with the <tt>ChangePartition()</tt> method.
<tt>ChangePartition()</tt> deletes the
old partition matrix and generates a new one with the specified number of cells
on each axis.
<p>
The optimum number of partition cells per axis changes with the number of
times <tt>Fill()</tt> will be called.  Although partitioning greatly speeds up
filling, it also adds a constant time delay into the code. When <tt>Fill()</tt>
is to be called many times, it is more efficient to divide the histogram into
a large number cells. However, if the histogram is to be filled only a few
times, it is better to divide into a small number of cells.
End_Html */



//______________________________________________________________________________
TH2Poly::TH2Poly()
{
   // Default Constructor. No boundaries specified.

   Initialize(0., 0., 0., 0., 25, 25);
   SetName("NoName");
   SetTitle("NoTitle");
   SetFloat();
}


//______________________________________________________________________________
TH2Poly::TH2Poly(const char *name,const char *title, Double_t xlow,Double_t xup
                                             , Double_t ylow,Double_t yup)
{
   // Constructor with specified name and boundaries,
   // but no partition cell number.

   Initialize(xlow, xup, ylow, yup, 25, 25);
   SetName(name);
   SetTitle(title);
   SetFloat(kFALSE);
}


//______________________________________________________________________________
TH2Poly::TH2Poly(const char *name,const char *title,
           Int_t nX, Double_t xlow, Double_t xup,
           Int_t nY, Double_t ylow, Double_t yup)
{
   // Constructor with specified name and boundaries and partition cell number.

   Initialize(xlow, xup, ylow, yup, nX, nY);
   SetName(name);
   SetTitle(title);
   SetFloat(kFALSE);
}


//______________________________________________________________________________
TH2Poly::~TH2Poly()
{
   // Destructor.

   delete[] fCells;
   delete[] fIsEmpty;
   delete[] fCompletelyInside;
   // delete at the end the bin List since it owns the objects
   delete fBins;
}


//______________________________________________________________________________
Int_t TH2Poly::AddBin(TObject *poly)
{
   // Adds a new bin to the histogram. It can be any object having the method
   // IsInside(). It returns the bin number in the histogram. It returns 0 if
   // it failed to add. To allow the histogram limits to expand when a bin
   // outside the limits is added, call SetFloat() before adding the bin.

   if (!poly) return 0;

   if (fBins == 0) {
      fBins = new TList();
      fBins->SetOwner();
   }

   fNcells++;
   TH2PolyBin *bin = new TH2PolyBin(poly, fNcells);

   // If the bin lies outside histogram boundaries, then extends the boundaries.
   // Also changes the partition information accordingly
   Bool_t flag = kFALSE;
   if (fFloat) {
      if (fXaxis.GetXmin() > bin->GetXMin()) {
         fXaxis.Set(100, bin->GetXMin(), fXaxis.GetXmax());
         flag = kTRUE;
      }
      if (fXaxis.GetXmax() < bin->GetXMax()) {
         fXaxis.Set(100, fXaxis.GetXmin(), bin->GetXMax());
         flag = kTRUE;
      }
      if (fYaxis.GetXmin() > bin->GetYMin()) {
         fYaxis.Set(100, bin->GetYMin(), fYaxis.GetXmax());
         flag = kTRUE;
      }
      if (fYaxis.GetXmax() < bin->GetYMax()) {
         fYaxis.Set(100, fYaxis.GetXmin(), bin->GetYMax());
         flag = kTRUE;
      }
      if (flag) ChangePartition(fCellX, fCellY);
   } else {
      /*Implement polygon clipping code here*/
   }

   fBins->Add((TObject*) bin);
   SetNewBinAdded(kTRUE);

   // Adds the bin to the partition matrix
   AddBinToPartition(bin);

   return fNcells;
}


//______________________________________________________________________________
Int_t TH2Poly::AddBin(Int_t n, const Double_t *x, const Double_t *y)
{
   // Adds a new bin to the histogram. The number of vertices and their (x,y)
   // coordinates are required as input. It returns the bin number in the
   // histogram.

   TGraph *g = new TGraph(n, x, y);
   Int_t bin = AddBin(g);
   return bin;
}


//______________________________________________________________________________
Int_t TH2Poly::AddBin(Double_t x1, Double_t y1, Double_t x2, Double_t  y2)
{
   // Add a new bin to the histogram. The bin shape is a rectangle.
   // It returns the bin number of the bin in the histogram.

   Double_t x[] = {x1, x1, x2, x2, x1};
   Double_t y[] = {y1, y2, y2, y1, y1};
   TGraph *g = new TGraph(5, x, y);
   Int_t bin = AddBin(g);
   return bin;
}


//______________________________________________________________________________
Bool_t TH2Poly::Add(const TH1 *h1, Double_t c1)
{
   // Performs the operation: this = this + c1*h1.

   Int_t bin;

   TH2Poly *h1p = (TH2Poly *)h1;

   // Check if number of bins is the same.
   if (h1p->GetNumberOfBins() != fNcells) {
      Error("Add","Attempt to add histograms with different number of bins");
      return kFALSE;
   }

   // Check if the bins are the same.
   TList *h1pBins = h1p->GetBins();
   TH2PolyBin *thisBin, *h1pBin;
   for (bin=1;bin<=fNcells;bin++) {
      thisBin = (TH2PolyBin*)fBins->At(bin-1);
      h1pBin  = (TH2PolyBin*)h1pBins->At(bin-1);
      if(thisBin->GetXMin() != h1pBin->GetXMin() ||
         thisBin->GetXMax() != h1pBin->GetXMax() ||
         thisBin->GetYMin() != h1pBin->GetYMin() ||
         thisBin->GetYMax() != h1pBin->GetYMax()) {
         Error("Add","Attempt to add histograms with different bin limits");
         return kFALSE;
      }
   }

   // Create Sumw2 if h1p has Sumw2 set
   if (fSumw2.fN == 0 && h1p->GetSumw2N() != 0) Sumw2();

   // Perform the Add.
   Double_t factor =1;
   if (h1p->GetNormFactor() != 0)
      factor = h1p->GetNormFactor()/h1p->GetSumOfWeights();
   for (bin=1;bin<=fNcells;bin++) {
      thisBin = (TH2PolyBin*)fBins->At(bin-1);
      h1pBin  = (TH2PolyBin*)h1pBins->At(bin-1);
      thisBin->SetContent(thisBin->GetContent()+c1*h1pBin->GetContent());
      if (fSumw2.fN) {
         Double_t e1 = factor*h1p->GetBinError(bin);
         fSumw2.fArray[bin] += c1*c1*e1*e1;
      }
   }
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH2Poly::Add(TF1 *, Double_t, Option_t *)
{
   // Performs the operation: this = this + c1*f1.

   Warning("Add","Not implement for TH2Poly");
   return kFALSE;
}


//______________________________________________________________________________
Bool_t TH2Poly::Add(const TH1 *, const TH1 *, Double_t, Double_t)
{
   // Replace contents of this histogram by the addition of h1 and h2.

   Warning("Add","Not implement for TH2Poly");
   return kFALSE;
}


//______________________________________________________________________________
void TH2Poly::AddBinToPartition(TH2PolyBin *bin)
{
   // Adds the input bin into the partition cell matrix. This method is called
   // in AddBin() and ChangePartition().

   // Cell Info
   Int_t nl, nr, mb, mt; // Max/min indices of the cells that contain the bin
   Double_t xclipl, xclipr, yclipb, yclipt; // x and y coordinates of a cell
   Double_t binXmax, binXmin, binYmax, binYmin; // The max/min bin coordinates

   binXmax = bin->GetXMax();
   binXmin = bin->GetXMin();
   binYmax = bin->GetYMax();
   binYmin = bin->GetYMin();
   nl = (Int_t)(floor((binXmin - fXaxis.GetXmin())/fStepX));
   nr = (Int_t)(floor((binXmax - fXaxis.GetXmin())/fStepX)); 
   mb = (Int_t)(floor((binYmin - fYaxis.GetXmin())/fStepY));
   mt = (Int_t)(floor((binYmax - fYaxis.GetXmin())/fStepY));

   // Make sure the array indices are correct.
   if (nr>=fCellX) nr = fCellX-1;
   if (mt>=fCellY) mt = fCellY-1;
   if (nl<0)       nl = 0;
   if (mb<0)       mb = 0;

   // number of cells in the grid
   //N.B. not to be confused with fNcells (the number of bins) ! 
   fNCells = fCellX*fCellY;

   // Loop over all cells
   for (int i = nl; i <= nr; i++) {
      xclipl = fXaxis.GetXmin() + i*fStepX;
      xclipr = xclipl + fStepX;
      for (int j = mb; j <= mt; j++) {
         yclipb = fYaxis.GetXmin() + j*fStepY;
         yclipt = yclipb + fStepY;

         // If the bin is completely inside the cell,
         // add that bin to the cell then return
         if ((binXmin >= xclipl) && (binXmax <= xclipr) &&
             (binYmax <= yclipt) && (binYmin >= yclipb)){
            fCells[i + j*fCellX].Add((TObject*) bin);
            fIsEmpty[i + j*fCellX] = kFALSE;  // Makes the cell non-empty
            return;
         }

         // If any of the sides of the cell intersect with any side of the bin,
         // add that bin then continue
         if (IsIntersecting(bin, xclipl, xclipr, yclipb, yclipt)) {
            fCells[i + j*fCellX].Add((TObject*) bin);
            fIsEmpty[i + j*fCellX] = kFALSE;  // Makes the cell non-empty
            continue;
         }
         // If a corner of the cell is inside the bin and since there is no
         // intersection, then that cell completely inside the bin.
         if((bin->IsInside(xclipl,yclipb)) || (bin->IsInside(xclipl,yclipt))){
            fCells[i + j*fCellX].Add((TObject*) bin);
            fIsEmpty[i + j*fCellX] = kFALSE;  // Makes the cell non-empty
            fCompletelyInside[i + fCellX*j] = kTRUE;
            continue;
         }
         if((bin->IsInside(xclipr,yclipb)) || (bin->IsInside(xclipr,yclipt))){
            fCells[i + j*fCellX].Add((TObject*) bin);
            fIsEmpty[i + j*fCellX] = kFALSE;  // Makes the cell non-empty
            fCompletelyInside[i + fCellX*j] = kTRUE;
            continue;
         }
      }
   }
}


//______________________________________________________________________________
void TH2Poly::ChangePartition(Int_t n, Int_t m)
{
   // Changes the number of partition cells in the histogram.
   // Deletes the old partition and constructs a new one.

   fCellX = n;                          // Set the number of cells
   fCellY = m;                          // Set the number of cells

   delete [] fCells;                    // Deletes the old partition

   // number of cells in the grid
   //N.B. not to be confused with fNcells (the number of bins) ! 
   fNCells = fCellX*fCellY;
   fCells  = new TList [fNCells];  // Sets an empty partition

   fStepX = (fXaxis.GetXmax() - fXaxis.GetXmin())/fCellX;
   fStepY = (fYaxis.GetXmax() - fYaxis.GetXmin())/fCellY;

   delete [] fIsEmpty;
   delete [] fCompletelyInside;
   fIsEmpty = new Bool_t [fNCells];
   fCompletelyInside = new Bool_t [fNCells];

   // Initializes the flags
   for (int i = 0; i<fNCells; i++) {
      fIsEmpty[i]          = kTRUE;
      fCompletelyInside[i] = kFALSE;
   }

   // TList iterator
   TIter    next(fBins);
   TObject  *obj;

   while((obj = next())){   // Loop over bins and add them to the partition
      AddBinToPartition((TH2PolyBin*) obj);
   }
}

//______________________________________________________________________________
void TH2Poly::ClearBinContents()
{
   // Clears the contents of all bins in the histogram.

   TIter next(fBins);
   TObject *obj;
   TH2PolyBin *bin;

   // Clears the bin contents
   while ((obj = next())) {
      bin = (TH2PolyBin*) obj;
      bin->ClearContent();
   }

   // Clears the statistics
   fTsumw   = 0;
   fTsumwx  = 0;
   fTsumwx2 = 0;
   fTsumwy  = 0;
   fTsumwy2 = 0;
   fEntries = 0;
}


//______________________________________________________________________________
void TH2Poly::Reset(Option_t *opt)
{
   // Reset this histogram: contents, errors, etc.

   TIter next(fBins);
   TObject *obj;
   TH2PolyBin *bin;

   // Clears the bin contents
   while ((obj = next())) {
      bin = (TH2PolyBin*) obj;
      bin->ClearContent();
   }

   TH2::Reset(opt);
}


//______________________________________________________________________________
TH1 *TH2Poly::DrawCopy(Option_t *option) const
{
   // Draw copy.

   TString opt = option;
   opt.ToLower();
   if (gPad && !opt.Contains("same")) gPad->Clear();
   TH2Poly *newth2 = (TH2Poly*)Clone();
   newth2->SetDirectory(0);
   newth2->SetBit(kCanDelete);
   newth2->AppendPad(option);
   return newth2;
}


//______________________________________________________________________________
Int_t TH2Poly::FindBin(Double_t x, Double_t y, Double_t)
{
   // Returns the bin number of the bin at the given coordinate. -1 to -9 are
   // the overflow and underflow bins.  overflow bin -5 is the unbinned areas in
   // the histogram (also called "the sea"). The third parameter can be left
   // blank.
   // The overflow/underflow bins are:
   //
   // -1 | -2 | -3
   // -------------
   // -4 | -5 | -6
   // -------------
   // -7 | -8 | -9
   //
   // where -5 means is the "sea" bin (i.e. unbinned areas)


   // Checks for overflow/underflow
   Int_t overflow = 0;
   if      (y > fYaxis.GetXmax()) overflow += -1;
   else if (y > fYaxis.GetXmin()) overflow += -4;
   else                           overflow += -7;
   if      (x > fXaxis.GetXmax()) overflow += -2;
   else if (x > fXaxis.GetXmin()) overflow += -1;
   if (overflow != -5) return overflow;

   // Finds the cell (x,y) coordinates belong to
   Int_t n = (Int_t)(floor((x-fXaxis.GetXmin())/fStepX));
   Int_t m = (Int_t)(floor((y-fYaxis.GetXmin())/fStepY));

   // Make sure the array indices are correct.
   if (n>=fCellX) n = fCellX-1;
   if (m>=fCellY) m = fCellY-1;
   if (n<0)       n = 0;
   if (m<0)       m = 0;

   if (fIsEmpty[n+fCellX*m]) return -5;

   TH2PolyBin *bin;

   TIter next(&fCells[n+fCellX*m]);
   TObject *obj;

   // Search for the bin in the cell
   while ((obj=next())) {
      bin  = (TH2PolyBin*)obj;
      if (bin->IsInside(x,y)) return bin->GetBinNumber();
   }

   // If the search has not returned a bin, the point must be on "the sea"
   return -5;
}


//______________________________________________________________________________
Int_t TH2Poly::Fill(Double_t x, Double_t y)
{
   // Increment the bin containing (x,y) by 1.
   // Uses the partitioning algorithm.

   return Fill(x, y, 1.0);
}


//______________________________________________________________________________
Int_t TH2Poly::Fill(Double_t x, Double_t y, Double_t w)
{
   // Increment the bin containing (x,y) by w.
   // Uses the partitioning algorithm.

   if (fNcells==0) return 0;
   Int_t overflow = 0;
   if      (y > fYaxis.GetXmax()) overflow += -1;
   else if (y > fYaxis.GetXmin()) overflow += -4;
   else                           overflow += -7;
   if      (x > fXaxis.GetXmax()) overflow += -2;
   else if(x > fXaxis.GetXmin())  overflow += -1;
   if (overflow != -5) {
      fOverflow[-overflow - 1]++;
      return overflow;
   }

   // Finds the cell (x,y) coordinates belong to
   Int_t n = (Int_t)(floor((x-fXaxis.GetXmin())/fStepX));
   Int_t m = (Int_t)(floor((y-fYaxis.GetXmin())/fStepY));

   // Make sure the array indices are correct.
   if (n>=fCellX) n = fCellX-1;
   if (m>=fCellY) m = fCellY-1;
   if (n<0)       n = 0;
   if (m<0)       m = 0;

   if (fIsEmpty[n+fCellX*m]) {
      fOverflow[4]++;
      return -5;
   }

   TH2PolyBin *bin;
   Int_t bi;

   TIter next(&fCells[n+fCellX*m]);
   TObject *obj;

   while ((obj=next())) {
      bin  = (TH2PolyBin*)obj;
      bi = bin->GetBinNumber()-1;
      if (bin->IsInside(x,y)) {
         bin->Fill(w);

         // Statistics
         fTsumw   = fTsumw + w;
         fTsumwx  = fTsumwx + w*x;
         fTsumwx2 = fTsumwx2 + w*x*x;
         fTsumwy  = fTsumwy + w*y;
         fTsumwy2 = fTsumwy2 + w*y*y;
         if (fSumw2.fN) fSumw2.fArray[bi] += w*w;
         fEntries++;

         SetBinContentChanged(kTRUE);

         return bin->GetBinNumber();
      }
   }

   fOverflow[4]++;
   return -5;
}


//______________________________________________________________________________
Int_t TH2Poly::Fill(const char* name, Double_t w)
{
   // Increment the bin named "name" by w.

   TString sname(name);

   TIter    next(fBins);
   TObject  *obj;
   TH2PolyBin *bin;

   while ((obj = next())) {
      bin = (TH2PolyBin*) obj;
      if (!sname.CompareTo(bin->GetPolygon()->GetName())) {
         bin->Fill(w);
         fEntries++;
         SetBinContentChanged(kTRUE);
         return bin->GetBinNumber();
      }
   }

   return 0;
}


//______________________________________________________________________________
void TH2Poly::FillN(Int_t ntimes, const Double_t* x, const Double_t* y,
                               const Double_t* w, Int_t stride)
{
   // Fills a 2-D histogram with an array of values and weights.
   //
   // ntimes:  number of entries in arrays x and w
   //          (array size must be ntimes*stride)
   // x:       array of x values to be histogrammed
   // y:       array of y values to be histogrammed
   // w:       array of weights
   // stride:  step size through arrays x, y and w

   for (int i = 0; i < ntimes; i += stride) {
      Fill(x[i], y[i], w[i]);
   }
}


//______________________________________________________________________________
Double_t TH2Poly::Integral(Option_t* option) const
{
   // Returns the integral of bin contents.
   // By default the integral is computed as the sum of bin contents.
   // If option "width" or "area" is specified, the integral is the sum of
   // the bin contents multiplied by the area of the bin.

   TString opt = option;
   opt.ToLower();

   if ((opt.Contains("width")) || (opt.Contains("area"))) {
      Double_t w;
      Double_t integral = 0.;

      TIter    next(fBins);
      TObject *obj;
      TH2PolyBin *bin;
      while ((obj=next())) {
         bin       = (TH2PolyBin*) obj;
         w         = bin->GetArea();
         integral += w*(bin->GetContent());
      }

      return integral;
   } else {
      return fTsumw;
   }
}


//______________________________________________________________________________
Double_t TH2Poly::GetBinContent(Int_t bin) const
{
   // Returns the content of the input bin
   // For the overflow/underflow/sea bins:
   //
   // -1 | -2 | -3
   // ---+----+----
   // -4 | -5 | -6
   // ---+----+----
   // -7 | -8 | -9
   //
   // where -5 is the "sea" bin (i.e. unbinned areas)

   if (bin > fNcells || bin == 0 || bin < -9) return 0; 
   if (bin<0) return fOverflow[-bin - 1];
   return ((TH2PolyBin*) fBins->At(bin-1))->GetContent();
}

//______________________________________________________________________________
Double_t TH2Poly::GetBinError(Int_t bin) const
{
   // Returns the value of error associated to bin number bin.
   // If the sum of squares of weights has been defined (via Sumw2),
   // this function returns the sqrt(sum of w2).
   // otherwise it returns the sqrt(contents) for this bin.

   if (bin < 0) bin = 0;
   if (bin > (fNcells)) return 0;
   if (fBuffer) ((TH1*)this)->BufferEmpty();
   if (fSumw2.fN) {
      Double_t err2 = fSumw2.fArray[bin-1];
      return TMath::Sqrt(err2);
   }
   Double_t error2 = TMath::Abs(GetBinContent(bin));
   return TMath::Sqrt(error2);
}


//______________________________________________________________________________
const char *TH2Poly::GetBinName(Int_t bin) const
{
   // Returns the bin name.

   if (bin > (fNcells))  return "";
   if (bin < 0)          return "";
   return ((TH2PolyBin*) fBins->At(bin-1))->GetPolygon()->GetName();
}


//______________________________________________________________________________
const char *TH2Poly::GetBinTitle(Int_t bin) const
{
   // Returns the bin title.

   if (bin > (fNcells))  return "";
   if (bin < 0)          return "";
   return ((TH2PolyBin*) fBins->At(bin-1))->GetPolygon()->GetTitle();
}


//______________________________________________________________________________
Double_t TH2Poly::GetMaximum() const
{
   // Returns the maximum value of the histogram.

   if (fNcells==0) return 0;
   if (fMaximum != -1111) return fMaximum;

   TH2PolyBin  *b;

   TIter next(fBins);
   TObject *obj;
   Double_t max,c;

   max = ((TH2PolyBin*) next())->GetContent();

   while ((obj=next())) {
      b = (TH2PolyBin*)obj;
      c = b->GetContent();
      if (c>max) max = c;
   }
   return max;
}


//______________________________________________________________________________
Double_t TH2Poly::GetMaximum(Double_t maxval) const
{
   // Returns the maximum value of the histogram that is less than maxval.

   if (fNcells==0) return 0;
   if (fMaximum != -1111) return fMaximum;

   TH2PolyBin  *b;

   TIter next(fBins);
   TObject *obj;
   Double_t max,c;

   max = ((TH2PolyBin*) next())->GetContent();

   while ((obj=next())) {
      b = (TH2PolyBin*)obj;
      c = b->GetContent();
      if (c>max && c<maxval) max=c;
   }
   return max;
}


//______________________________________________________________________________
Double_t TH2Poly::GetMinimum() const
{
   // Returns the minimum value of the histogram.

   if (fNcells==0) return 0;
   if (fMinimum != -1111) return fMinimum;

   TH2PolyBin  *b;

   TIter next(fBins);
   TObject *obj;
   Double_t min,c;

   min = ((TH2PolyBin*) next())->GetContent();

   while ((obj=next())) {
      b = (TH2PolyBin*)obj;
      c = b->GetContent();
      if (c<min) min=c;
   }
   return min;
}


//______________________________________________________________________________
Double_t TH2Poly::GetMinimum(Double_t minval) const
{
   // Returns the minimum value of the histogram that is greater than minval.

   if (fNcells==0) return 0;
   if (fMinimum != -1111) return fMinimum;

   TH2PolyBin  *b;

   TIter next(fBins);
   TObject *obj;
   Double_t min,c;

   min = ((TH2PolyBin*) next())->GetContent();

   while ((obj=next())) {
      b = (TH2PolyBin*)obj;
      c = b->GetContent();
      if (c<min && c>minval) min=c;
   }
   return min;
}


//______________________________________________________________________________
void TH2Poly::Honeycomb(Double_t xstart, Double_t ystart, Double_t a,
                     Int_t k, Int_t s)
{
   // Bins the histogram using a honeycomb structure

   // Add the bins
   Double_t numberOfHexagonsInTheRow;
   Double_t x[6], y[6];
   Double_t xloop, yloop, xtemp;
   xloop = xstart; yloop = ystart + a/2.0;
   for (int sCounter = 0; sCounter < s; sCounter++) {

      xtemp = xloop; // Resets the temp variable

      // Determine the number of hexagons in that row
      if(sCounter%2 == 0){numberOfHexagonsInTheRow = k;}
      else{numberOfHexagonsInTheRow = k - 1;}

      for (int kCounter = 0; kCounter <  numberOfHexagonsInTheRow; kCounter++) {

         // Go around the hexagon
         x[0] = xtemp;
         y[0] = yloop;
         x[1] = x[0];
         y[1] = y[0] + a;
         x[2] = x[1] + a*TMath::Sqrt(3)/2.0;
         y[2] = y[1] + a/2.0;
         x[3] = x[2] + a*TMath::Sqrt(3)/2.0;
         y[3] = y[1];
         x[4] = x[3];
         y[4] = y[0];
         x[5] = x[2];
         y[5] = y[4] - a/2.0;

         this->AddBin(6, x, y);

         // Go right
         xtemp += a*TMath::Sqrt(3);
      }

      // Increment the starting position
      if (sCounter%2 == 0) xloop += a*TMath::Sqrt(3)/2.0;
      else                 xloop -= a*TMath::Sqrt(3)/2.0;
      yloop += 1.5*a;
   }
}


//______________________________________________________________________________
void TH2Poly::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.

   Int_t i;
   fDimension = 2;  //The dimesion of the histogram

   fBins   = 0;
   fNcells = 0;

   // Sets the boundaries of the histogram
   fXaxis.Set(100, xlow, xup);
   fYaxis.Set(100, ylow, yup);

   for (i=0; i<9; i++) fOverflow[i] = 0.;

   // Statistics
   fEntries = 0;   // The total number of entries
   fTsumw   = 0.;  // Total amount of content in the histogram
   fTsumwx  = 0.;  // Weighted sum of x coordinates
   fTsumwx2 = 0.;  // Weighted sum of the squares of x coordinates
   fTsumwy2 = 0.;  // Weighted sum of the squares of y coordinates
   fTsumwy  = 0.;  // Weighted sum of y coordinates

   fCellX = n; // Set the number of cells to default
   fCellY = m; // Set the number of cells to default

   // number of cells in the grid
   //N.B. not to be confused with fNcells (the number of bins) ! 
   fNCells = fCellX*fCellY;
   fCells  = new TList [fNCells];  // Sets an empty partition
   fStepX  = (fXaxis.GetXmax() - fXaxis.GetXmin())/fCellX; // Cell width
   fStepY  = (fYaxis.GetXmax() - fYaxis.GetXmin())/fCellY; // Cell height

   fIsEmpty = new Bool_t [fNCells]; // Empty partition
   fCompletelyInside = new Bool_t [fNCells]; // Cell is completely inside bin

   for (i = 0; i<fNCells; i++) {   // Initializes the flags
      fIsEmpty[i] = kTRUE;
      fCompletelyInside[i] = kFALSE;
   }

   // 3D Painter flags
   SetNewBinAdded(kFALSE);
   SetBinContentChanged(kFALSE);
}


//______________________________________________________________________________
Bool_t TH2Poly::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, yclipb, yclipt)

   Int_t     gn;
   Double_t *gx;
   Double_t *gy;
   Bool_t inter = kFALSE;
   TObject *poly = bin->GetPolygon();

   if (poly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)poly;
      gx = g->GetX();
      gy = g->GetY();
      gn = g->GetN();
      inter = IsIntersectingPolygon(gn, gx, gy, xclipl, xclipr, yclipb, yclipt);
   }

   if (poly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)poly;
      TList *gl = mg->GetListOfGraphs();
      if (!gl) return inter;
      TGraph *g;
      TIter next(gl);
      while ((g = (TGraph*) next())) {
         gx = g->GetX();
         gy = g->GetY();
         gn = g->GetN();
         inter = IsIntersectingPolygon(gn, gx, gy, xclipl, xclipr,
                                                   yclipb, yclipt);
         if (inter) return inter;
      }
   }

   return inter;
}

//______________________________________________________________________________
Bool_t TH2Poly::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, xclipr, yclipb, yclipt)

   Bool_t p0R, p0L, p0T, p0B, p0xM, p0yM, p1R, p1L, p1T;
   Bool_t p1B, p1xM, p1yM, p0In, p1In;

   for (int counter = 0; counter < (bn-1); counter++) {
      // If both are on the same side, return kFALSE
      p0L = x[counter]     <= xclipl; // Point 0 is on the left
      p1L = x[counter + 1] <= xclipl; // Point 1 is on the left
      if (p0L && p1L) continue;
      p0R = x[counter]     >= xclipr; // Point 0 is on the right
      p1R = x[counter + 1] >= xclipr; // Point 1 is on the right
      if (p0R && p1R) continue;
      p0T = y[counter]     >= yclipt; // Point 0 is at the top
      p1T = y[counter + 1] >= yclipt; // Point 1 is at the top
      if (p0T && p1T) continue;
      p0B = y[counter]     <= yclipb; // Point 0 is at the bottom
      p1B = y[counter + 1] <= yclipb; // Point 1 is at the bottom
      if (p0B && p1B) continue;

      // Checks to see if any are inside
      p0xM = !p0R && !p0L; // Point 0 is inside along x
      p0yM = !p0T && !p0B; // Point 1 is inside along x
      p1xM = !p1R && !p1L; // Point 0 is inside along y
      p1yM = !p1T && !p1B; // Point 1 is inside along y
      p0In = p0xM && p0yM; // Point 0 is inside
      p1In = p1xM && p1yM; // Point 1 is inside
      if (p0In) {
         if (p1In) continue;
         return kTRUE;
      } else {
         if (p1In) return kTRUE;
      }

      // We know by now that the points are not in the same side and not inside.

      // Checks to see if they are opposite

      if (p0xM && p1xM) return kTRUE;
      if (p0yM && p1yM) return kTRUE;

      // We now know that the points are in different x and y indices

      Double_t xcoord[3], ycoord[3];
      xcoord[0] = x[counter];
      xcoord[1] = x[counter + 1];
      ycoord[0] = y[counter];
      ycoord[1] = y[counter + 1];

      if (p0L) {
         if(p1T){
            xcoord[2] = xclipl;
            ycoord[2] = yclipb;
            if((TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord)) ||
               (TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord))) continue;
            else return kTRUE;
         } else if (p1B) {
            xcoord[2] = xclipl;
            ycoord[2] = yclipt;
            if((TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) ||
               (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord))) continue;
            else return kTRUE;
         } else { // p1yM
            if (p0T) {
               xcoord[2] = xclipl;
               ycoord[2] = yclipb;
               if (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord)) continue;
               else return kTRUE;
            }
            if (p0B) {
               xcoord[2] = xclipl;
               ycoord[2] = yclipt;
               if (TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord)) continue;
               else return kTRUE;
            }
         }
      } else if (p0R) {
         if (p1T) {
            xcoord[2] = xclipl;
            ycoord[2] = yclipb;
            if ((TMath::IsInside(xclipr, yclipb, 3, xcoord, ycoord)) ||
                (TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord))) continue;
            else return kTRUE;
         } else if (p1B) {
            xcoord[2] = xclipl;
            ycoord[2] = yclipt;
            if ((TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) ||
                (TMath::IsInside(xclipr, yclipt, 3, xcoord, ycoord))) continue;
            else return kTRUE;
         } else{ // p1yM
            if (p0T) {
               xcoord[2] = xclipr;
               ycoord[2] = yclipb;
               if (TMath::IsInside(xclipl, yclipt, 3, xcoord, ycoord)) continue;
               else return kTRUE;
            }
            if (p0B) {
               xcoord[2] = xclipr;
               ycoord[2] = yclipt;
               if (TMath::IsInside(xclipl, yclipb, 3, xcoord, ycoord)) continue;
               else return kTRUE;
            }
         }
      }
   }
   return kFALSE;
}


//______________________________________________________________________________
Long64_t TH2Poly::Merge(TCollection *)
{
   Error("Merge","Cannot merge TH2Poly");
   return 0;
}


//______________________________________________________________________________
void TH2Poly::SavePrimitive(ostream &out, Option_t *option)
{
   // Save primitive as a C++ statement(s) on output stream out

   out <<"   "<<endl;
   out <<"   "<< ClassName() <<" *";

   //histogram pointer has by default the histogram name.
   //however, in case histogram has no directory, it is safer to add a
   //incremental suffix
   static Int_t hcounter = 0;
   TString histName = GetName();
   if (!fDirectory && !histName.Contains("Graph")) {
      hcounter++;
      histName += "__";
      histName += hcounter;
   }
   const char *hname = histName.Data();

   //Construct the class initialization
   out << hname << " = new " << ClassName() << "(\"" << hname << "\", \""
       << GetTitle() << "\", " << fCellX << ", " << fXaxis.GetXmin()
       << ", " << fXaxis.GetXmax()
       << ", " << fCellY << ", " << fYaxis.GetXmin() << ", "
       << fYaxis.GetXmax() << ");" << endl;

   // Save Bins
   TIter       next(fBins);
   TObject    *obj;
   TH2PolyBin *th2pBin;

   while((obj = next())){
      th2pBin = (TH2PolyBin*) obj;
      th2pBin->GetPolygon()->SavePrimitive(out,
                                           Form("th2poly%s",histName.Data()));
   }

   // save bin contents
   out<<"   "<<endl;
   Int_t bin;
   for (bin=1;bin<=fNcells;bin++) {
      Double_t bc = GetBinContent(bin);
      if (bc) {
         out<<"   "<<hname<<"->SetBinContent("<<bin<<","<<bc<<");"<<endl;
      }
   }

   // save bin errors
   if (fSumw2.fN) {
      for (bin=1;bin<=fNcells;bin++) {
         Double_t be = GetBinError(bin);
         if (be) {
            out<<"   "<<hname<<"->SetBinError("<<bin<<","<<be<<");"<<endl;
         }
      }
   }
   TH1::SavePrimitiveHelp(out, hname, option);
}


//______________________________________________________________________________
void TH2Poly::Scale(Double_t c1, Option_t*)
{
   // Multiply this histogram by a constant c1.

   for( int i = 0; i < this->GetNumberOfBins(); i++ ) {
      this->SetBinContent(i+1, c1*this->GetBinContent(i+1));
   }
}


//______________________________________________________________________________
void TH2Poly::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 overflows and the sea 

   if (bin > (fNcells) || bin == 0 || bin < -9 ) return;
   if (bin > 0) 
      ((TH2PolyBin*) fBins->At(bin-1))->SetContent(content);
   else
      fOverflow[-bin - 1] += content;
   SetBinContentChanged(kTRUE);
}

//______________________________________________________________________________
void TH2Poly::SetFloat(Bool_t flag)
{
   // When set to kTRUE, allows the histogram to expand if a bin outside the
   // limits is added.

   fFloat = flag;
}


//______________________________________________________________________________
TH2PolyBin::TH2PolyBin()
{
   // Default constructor.

   fPoly    = 0;
   fContent = 0.;
   fNumber  = 0;
   fXmax    = -1111;
   fXmin    = -1111;
   fYmax    = -1111;
   fYmin    = -1111;
   fArea    = 0;
   SetChanged(kTRUE);
}


//______________________________________________________________________________
TH2PolyBin::TH2PolyBin(TObject *poly, Int_t bin_number)
{
   // Normal constructor.

   fContent = 0.;
   fNumber  = bin_number;
   fArea    = 0.;
   fPoly    = poly;
   fXmax    = -1111;
   fXmin    = -1111;
   fYmax    = -1111;
   fYmin    = -1111;
   SetChanged(kTRUE);
}


//______________________________________________________________________________
TH2PolyBin::~TH2PolyBin()
{
   // Destructor.

   if (fPoly) delete fPoly;
}


//______________________________________________________________________________
Double_t TH2PolyBin::GetArea()
{
   // Returns the area of the bin.

   Int_t     bn;

   if (fArea == 0) {
      if (fPoly->IsA() == TGraph::Class()) {
         TGraph *g = (TGraph*)fPoly;
         bn    = g->GetN();
         fArea = g->Integral(0,bn-1);
      }

      if (fPoly->IsA() == TMultiGraph::Class()) {
         TMultiGraph *mg = (TMultiGraph*)fPoly;
         TList *gl = mg->GetListOfGraphs();
         if (!gl) return fArea;
         TGraph *g;
         TIter next(gl);
         while ((g = (TGraph*) next())) {
            bn    = g->GetN();
            fArea = fArea + g->Integral(0,bn-1);
         }
      }
   }

   return fArea;
}


//______________________________________________________________________________
Double_t TH2PolyBin::GetXMax()
{
   // Returns the maximum value for the x coordinates of the bin.

   if (fXmax != -1111) return fXmax;

   Int_t     bn,i;
   Double_t *bx;

   if (fPoly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)fPoly;
      bx    = g->GetX();
      bn    = g->GetN();
      fXmax = bx[0];
      for (i=1; i<bn; i++) {if (fXmax < bx[i]) fXmax = bx[i];}
   }

   if (fPoly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)fPoly;
      TList *gl = mg->GetListOfGraphs();
      if (!gl) return fXmax;
      TGraph *g;
      TIter next(gl);
      Bool_t first = kTRUE;
      while ((g = (TGraph*) next())) {
         bx = g->GetX();
         bn = g->GetN();
         if (first) {fXmax = bx[0]; first = kFALSE;}
         for (i=0; i<bn; i++) {if (fXmax < bx[i]) fXmax = bx[i];}
      }
   }

   return fXmax;
}


//______________________________________________________________________________
Double_t TH2PolyBin::GetXMin()
{
   // Returns the minimum value for the x coordinates of the bin.

   if (fXmin != -1111) return fXmin;

   Int_t     bn,i;
   Double_t *bx;

   if (fPoly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)fPoly;
      bx    = g->GetX();
      bn    = g->GetN();
      fXmin = bx[0];
      for (i=1; i<bn; i++) {if (fXmin > bx[i]) fXmin = bx[i];}
   }

   if (fPoly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)fPoly;
      TList *gl = mg->GetListOfGraphs();
      if (!gl) return fXmin;
      TGraph *g;
      TIter next(gl);
      Bool_t first = kTRUE;
      while ((g = (TGraph*) next())) {
         bx = g->GetX();
         bn = g->GetN();
         if (first) {fXmin = bx[0]; first = kFALSE;}
         for (i=0; i<bn; i++) {if (fXmin > bx[i]) fXmin = bx[i];}
      }
   }

   return fXmin;
}


//______________________________________________________________________________
Double_t TH2PolyBin::GetYMax()
{
   // Returns the maximum value for the y coordinates of the bin.

   if (fYmax != -1111) return fYmax;

   Int_t     bn,i;
   Double_t *by;

   if (fPoly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)fPoly;
      by    = g->GetY();
      bn    = g->GetN();
      fYmax = by[0];
      for (i=1; i<bn; i++) {if (fYmax < by[i]) fYmax = by[i];}
   }

   if (fPoly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)fPoly;
      TList *gl = mg->GetListOfGraphs();
      if (!gl) return fYmax;
      TGraph *g;
      TIter next(gl);
      Bool_t first = kTRUE;
      while ((g = (TGraph*) next())) {
         by = g->GetY();
         bn = g->GetN();
         if (first) {fYmax = by[0]; first = kFALSE;}
         for (i=0; i<bn; i++) {if (fYmax < by[i]) fYmax = by[i];}
      }
   }

   return fYmax;
}


//______________________________________________________________________________
Double_t TH2PolyBin::GetYMin()
{
   // Returns the minimum value for the y coordinates of the bin.

   if (fYmin != -1111) return fYmin;

   Int_t     bn,i;
   Double_t *by;

   if (fPoly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)fPoly;
      by    = g->GetY();
      bn    = g->GetN();
      fYmin = by[0];
      for (i=1; i<bn; i++) {if (fYmin > by[i]) fYmin = by[i];}
   }

   if (fPoly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)fPoly;
      TList *gl = mg->GetListOfGraphs();
      if (!gl) return fYmin;
      TGraph *g;
      TIter next(gl);
      Bool_t first = kTRUE;
      while ((g = (TGraph*) next())) {
         by = g->GetY();
         bn = g->GetN();
         if (first) {fYmin = by[0]; first = kFALSE;}
         for (i=0; i<bn; i++) {if (fYmin > by[i]) fYmin = by[i];}
      }
   }

   return fYmin;
}


//______________________________________________________________________________
Bool_t TH2PolyBin::IsInside(Double_t x, Double_t y) const
{
   // Return "true" if the point (x,y) is inside the bin.

   Int_t in=0;

   if (fPoly->IsA() == TGraph::Class()) {
      TGraph *g = (TGraph*)fPoly;
      in = g->IsInside(x, y);
   }

   if (fPoly->IsA() == TMultiGraph::Class()) {
      TMultiGraph *mg = (TMultiGraph*)fPoly;
      in = mg->IsInside(x, y);
   }

   return in;
}
 TH2Poly.cxx:1
 TH2Poly.cxx:2
 TH2Poly.cxx:3
 TH2Poly.cxx:4
 TH2Poly.cxx:5
 TH2Poly.cxx:6
 TH2Poly.cxx:7
 TH2Poly.cxx:8
 TH2Poly.cxx:9
 TH2Poly.cxx:10
 TH2Poly.cxx:11
 TH2Poly.cxx:12
 TH2Poly.cxx:13
 TH2Poly.cxx:14
 TH2Poly.cxx:15
 TH2Poly.cxx:16
 TH2Poly.cxx:17
 TH2Poly.cxx:18
 TH2Poly.cxx:19
 TH2Poly.cxx:20
 TH2Poly.cxx:21
 TH2Poly.cxx:22
 TH2Poly.cxx:23
 TH2Poly.cxx:24
 TH2Poly.cxx:25
 TH2Poly.cxx:26
 TH2Poly.cxx:27
 TH2Poly.cxx:28
 TH2Poly.cxx:29
 TH2Poly.cxx:30
 TH2Poly.cxx:31
 TH2Poly.cxx:32
 TH2Poly.cxx:33
 TH2Poly.cxx:34
 TH2Poly.cxx:35
 TH2Poly.cxx:36
 TH2Poly.cxx:37
 TH2Poly.cxx:38
 TH2Poly.cxx:39
 TH2Poly.cxx:40
 TH2Poly.cxx:41
 TH2Poly.cxx:42
 TH2Poly.cxx:43
 TH2Poly.cxx:44
 TH2Poly.cxx:45
 TH2Poly.cxx:46
 TH2Poly.cxx:47
 TH2Poly.cxx:48
 TH2Poly.cxx:49
 TH2Poly.cxx:50
 TH2Poly.cxx:51
 TH2Poly.cxx:52
 TH2Poly.cxx:53
 TH2Poly.cxx:54
 TH2Poly.cxx:55
 TH2Poly.cxx:56
 TH2Poly.cxx:57
 TH2Poly.cxx:58
 TH2Poly.cxx:59
 TH2Poly.cxx:60
 TH2Poly.cxx:61
 TH2Poly.cxx:62
 TH2Poly.cxx:63
 TH2Poly.cxx:64
 TH2Poly.cxx:65
 TH2Poly.cxx:66
 TH2Poly.cxx:67
 TH2Poly.cxx:68
 TH2Poly.cxx:69
 TH2Poly.cxx:70
 TH2Poly.cxx:71
 TH2Poly.cxx:72
 TH2Poly.cxx:73
 TH2Poly.cxx:74
 TH2Poly.cxx:75
 TH2Poly.cxx:76
 TH2Poly.cxx:77
 TH2Poly.cxx:78
 TH2Poly.cxx:79
 TH2Poly.cxx:80
 TH2Poly.cxx:81
 TH2Poly.cxx:82
 TH2Poly.cxx:83
 TH2Poly.cxx:84
 TH2Poly.cxx:85
 TH2Poly.cxx:86
 TH2Poly.cxx:87
 TH2Poly.cxx:88
 TH2Poly.cxx:89
 TH2Poly.cxx:90
 TH2Poly.cxx:91
 TH2Poly.cxx:92
 TH2Poly.cxx:93
 TH2Poly.cxx:94
 TH2Poly.cxx:95
 TH2Poly.cxx:96
 TH2Poly.cxx:97
 TH2Poly.cxx:98
 TH2Poly.cxx:99
 TH2Poly.cxx:100
 TH2Poly.cxx:101
 TH2Poly.cxx:102
 TH2Poly.cxx:103
 TH2Poly.cxx:104
 TH2Poly.cxx:105
 TH2Poly.cxx:106
 TH2Poly.cxx:107
 TH2Poly.cxx:108
 TH2Poly.cxx:109
 TH2Poly.cxx:110
 TH2Poly.cxx:111
 TH2Poly.cxx:112
 TH2Poly.cxx:113
 TH2Poly.cxx:114
 TH2Poly.cxx:115
 TH2Poly.cxx:116
 TH2Poly.cxx:117
 TH2Poly.cxx:118
 TH2Poly.cxx:119
 TH2Poly.cxx:120
 TH2Poly.cxx:121
 TH2Poly.cxx:122
 TH2Poly.cxx:123
 TH2Poly.cxx:124
 TH2Poly.cxx:125
 TH2Poly.cxx:126
 TH2Poly.cxx:127
 TH2Poly.cxx:128
 TH2Poly.cxx:129
 TH2Poly.cxx:130
 TH2Poly.cxx:131
 TH2Poly.cxx:132
 TH2Poly.cxx:133
 TH2Poly.cxx:134
 TH2Poly.cxx:135
 TH2Poly.cxx:136
 TH2Poly.cxx:137
 TH2Poly.cxx:138
 TH2Poly.cxx:139
 TH2Poly.cxx:140
 TH2Poly.cxx:141
 TH2Poly.cxx:142
 TH2Poly.cxx:143
 TH2Poly.cxx:144
 TH2Poly.cxx:145
 TH2Poly.cxx:146
 TH2Poly.cxx:147
 TH2Poly.cxx:148
 TH2Poly.cxx:149
 TH2Poly.cxx:150
 TH2Poly.cxx:151
 TH2Poly.cxx:152
 TH2Poly.cxx:153
 TH2Poly.cxx:154
 TH2Poly.cxx:155
 TH2Poly.cxx:156
 TH2Poly.cxx:157
 TH2Poly.cxx:158
 TH2Poly.cxx:159
 TH2Poly.cxx:160
 TH2Poly.cxx:161
 TH2Poly.cxx:162
 TH2Poly.cxx:163
 TH2Poly.cxx:164
 TH2Poly.cxx:165
 TH2Poly.cxx:166
 TH2Poly.cxx:167
 TH2Poly.cxx:168
 TH2Poly.cxx:169
 TH2Poly.cxx:170
 TH2Poly.cxx:171
 TH2Poly.cxx:172
 TH2Poly.cxx:173
 TH2Poly.cxx:174
 TH2Poly.cxx:175
 TH2Poly.cxx:176
 TH2Poly.cxx:177
 TH2Poly.cxx:178
 TH2Poly.cxx:179
 TH2Poly.cxx:180
 TH2Poly.cxx:181
 TH2Poly.cxx:182
 TH2Poly.cxx:183
 TH2Poly.cxx:184
 TH2Poly.cxx:185
 TH2Poly.cxx:186
 TH2Poly.cxx:187
 TH2Poly.cxx:188
 TH2Poly.cxx:189
 TH2Poly.cxx:190
 TH2Poly.cxx:191
 TH2Poly.cxx:192
 TH2Poly.cxx:193
 TH2Poly.cxx:194
 TH2Poly.cxx:195
 TH2Poly.cxx:196
 TH2Poly.cxx:197
 TH2Poly.cxx:198
 TH2Poly.cxx:199
 TH2Poly.cxx:200
 TH2Poly.cxx:201
 TH2Poly.cxx:202
 TH2Poly.cxx:203
 TH2Poly.cxx:204
 TH2Poly.cxx:205
 TH2Poly.cxx:206
 TH2Poly.cxx:207
 TH2Poly.cxx:208
 TH2Poly.cxx:209
 TH2Poly.cxx:210
 TH2Poly.cxx:211
 TH2Poly.cxx:212
 TH2Poly.cxx:213
 TH2Poly.cxx:214
 TH2Poly.cxx:215
 TH2Poly.cxx:216
 TH2Poly.cxx:217
 TH2Poly.cxx:218
 TH2Poly.cxx:219
 TH2Poly.cxx:220
 TH2Poly.cxx:221
 TH2Poly.cxx:222
 TH2Poly.cxx:223
 TH2Poly.cxx:224
 TH2Poly.cxx:225
 TH2Poly.cxx:226
 TH2Poly.cxx:227
 TH2Poly.cxx:228
 TH2Poly.cxx:229
 TH2Poly.cxx:230
 TH2Poly.cxx:231
 TH2Poly.cxx:232
 TH2Poly.cxx:233
 TH2Poly.cxx:234
 TH2Poly.cxx:235
 TH2Poly.cxx:236
 TH2Poly.cxx:237
 TH2Poly.cxx:238
 TH2Poly.cxx:239
 TH2Poly.cxx:240
 TH2Poly.cxx:241
 TH2Poly.cxx:242
 TH2Poly.cxx:243
 TH2Poly.cxx:244
 TH2Poly.cxx:245
 TH2Poly.cxx:246
 TH2Poly.cxx:247
 TH2Poly.cxx:248
 TH2Poly.cxx:249
 TH2Poly.cxx:250
 TH2Poly.cxx:251
 TH2Poly.cxx:252
 TH2Poly.cxx:253
 TH2Poly.cxx:254
 TH2Poly.cxx:255
 TH2Poly.cxx:256
 TH2Poly.cxx:257
 TH2Poly.cxx:258
 TH2Poly.cxx:259
 TH2Poly.cxx:260
 TH2Poly.cxx:261
 TH2Poly.cxx:262
 TH2Poly.cxx:263
 TH2Poly.cxx:264
 TH2Poly.cxx:265
 TH2Poly.cxx:266
 TH2Poly.cxx:267
 TH2Poly.cxx:268
 TH2Poly.cxx:269
 TH2Poly.cxx:270
 TH2Poly.cxx:271
 TH2Poly.cxx:272
 TH2Poly.cxx:273
 TH2Poly.cxx:274
 TH2Poly.cxx:275
 TH2Poly.cxx:276
 TH2Poly.cxx:277
 TH2Poly.cxx:278
 TH2Poly.cxx:279
 TH2Poly.cxx:280
 TH2Poly.cxx:281
 TH2Poly.cxx:282
 TH2Poly.cxx:283
 TH2Poly.cxx:284
 TH2Poly.cxx:285
 TH2Poly.cxx:286
 TH2Poly.cxx:287
 TH2Poly.cxx:288
 TH2Poly.cxx:289
 TH2Poly.cxx:290
 TH2Poly.cxx:291
 TH2Poly.cxx:292
 TH2Poly.cxx:293
 TH2Poly.cxx:294
 TH2Poly.cxx:295
 TH2Poly.cxx:296
 TH2Poly.cxx:297
 TH2Poly.cxx:298
 TH2Poly.cxx:299
 TH2Poly.cxx:300
 TH2Poly.cxx:301
 TH2Poly.cxx:302
 TH2Poly.cxx:303
 TH2Poly.cxx:304
 TH2Poly.cxx:305
 TH2Poly.cxx:306
 TH2Poly.cxx:307
 TH2Poly.cxx:308
 TH2Poly.cxx:309
 TH2Poly.cxx:310
 TH2Poly.cxx:311
 TH2Poly.cxx:312
 TH2Poly.cxx:313
 TH2Poly.cxx:314
 TH2Poly.cxx:315
 TH2Poly.cxx:316
 TH2Poly.cxx:317
 TH2Poly.cxx:318
 TH2Poly.cxx:319
 TH2Poly.cxx:320
 TH2Poly.cxx:321
 TH2Poly.cxx:322
 TH2Poly.cxx:323
 TH2Poly.cxx:324
 TH2Poly.cxx:325
 TH2Poly.cxx:326
 TH2Poly.cxx:327
 TH2Poly.cxx:328
 TH2Poly.cxx:329
 TH2Poly.cxx:330
 TH2Poly.cxx:331
 TH2Poly.cxx:332
 TH2Poly.cxx:333
 TH2Poly.cxx:334
 TH2Poly.cxx:335
 TH2Poly.cxx:336
 TH2Poly.cxx:337
 TH2Poly.cxx:338
 TH2Poly.cxx:339
 TH2Poly.cxx:340
 TH2Poly.cxx:341
 TH2Poly.cxx:342
 TH2Poly.cxx:343
 TH2Poly.cxx:344
 TH2Poly.cxx:345
 TH2Poly.cxx:346
 TH2Poly.cxx:347
 TH2Poly.cxx:348
 TH2Poly.cxx:349
 TH2Poly.cxx:350
 TH2Poly.cxx:351
 TH2Poly.cxx:352
 TH2Poly.cxx:353
 TH2Poly.cxx:354
 TH2Poly.cxx:355
 TH2Poly.cxx:356
 TH2Poly.cxx:357
 TH2Poly.cxx:358
 TH2Poly.cxx:359
 TH2Poly.cxx:360
 TH2Poly.cxx:361
 TH2Poly.cxx:362
 TH2Poly.cxx:363
 TH2Poly.cxx:364
 TH2Poly.cxx:365
 TH2Poly.cxx:366
 TH2Poly.cxx:367
 TH2Poly.cxx:368
 TH2Poly.cxx:369
 TH2Poly.cxx:370
 TH2Poly.cxx:371
 TH2Poly.cxx:372
 TH2Poly.cxx:373
 TH2Poly.cxx:374
 TH2Poly.cxx:375
 TH2Poly.cxx:376
 TH2Poly.cxx:377
 TH2Poly.cxx:378
 TH2Poly.cxx:379
 TH2Poly.cxx:380
 TH2Poly.cxx:381
 TH2Poly.cxx:382
 TH2Poly.cxx:383
 TH2Poly.cxx:384
 TH2Poly.cxx:385
 TH2Poly.cxx:386
 TH2Poly.cxx:387
 TH2Poly.cxx:388
 TH2Poly.cxx:389
 TH2Poly.cxx:390
 TH2Poly.cxx:391
 TH2Poly.cxx:392
 TH2Poly.cxx:393
 TH2Poly.cxx:394
 TH2Poly.cxx:395
 TH2Poly.cxx:396
 TH2Poly.cxx:397
 TH2Poly.cxx:398
 TH2Poly.cxx:399
 TH2Poly.cxx:400
 TH2Poly.cxx:401
 TH2Poly.cxx:402
 TH2Poly.cxx:403
 TH2Poly.cxx:404
 TH2Poly.cxx:405
 TH2Poly.cxx:406
 TH2Poly.cxx:407
 TH2Poly.cxx:408
 TH2Poly.cxx:409
 TH2Poly.cxx:410
 TH2Poly.cxx:411
 TH2Poly.cxx:412
 TH2Poly.cxx:413
 TH2Poly.cxx:414
 TH2Poly.cxx:415
 TH2Poly.cxx:416
 TH2Poly.cxx:417
 TH2Poly.cxx:418
 TH2Poly.cxx:419
 TH2Poly.cxx:420
 TH2Poly.cxx:421
 TH2Poly.cxx:422
 TH2Poly.cxx:423
 TH2Poly.cxx:424
 TH2Poly.cxx:425
 TH2Poly.cxx:426
 TH2Poly.cxx:427
 TH2Poly.cxx:428
 TH2Poly.cxx:429
 TH2Poly.cxx:430
 TH2Poly.cxx:431
 TH2Poly.cxx:432
 TH2Poly.cxx:433
 TH2Poly.cxx:434
 TH2Poly.cxx:435
 TH2Poly.cxx:436
 TH2Poly.cxx:437
 TH2Poly.cxx:438
 TH2Poly.cxx:439
 TH2Poly.cxx:440
 TH2Poly.cxx:441
 TH2Poly.cxx:442
 TH2Poly.cxx:443
 TH2Poly.cxx:444
 TH2Poly.cxx:445
 TH2Poly.cxx:446
 TH2Poly.cxx:447
 TH2Poly.cxx:448
 TH2Poly.cxx:449
 TH2Poly.cxx:450
 TH2Poly.cxx:451
 TH2Poly.cxx:452
 TH2Poly.cxx:453
 TH2Poly.cxx:454
 TH2Poly.cxx:455
 TH2Poly.cxx:456
 TH2Poly.cxx:457
 TH2Poly.cxx:458
 TH2Poly.cxx:459
 TH2Poly.cxx:460
 TH2Poly.cxx:461
 TH2Poly.cxx:462
 TH2Poly.cxx:463
 TH2Poly.cxx:464
 TH2Poly.cxx:465
 TH2Poly.cxx:466
 TH2Poly.cxx:467
 TH2Poly.cxx:468
 TH2Poly.cxx:469
 TH2Poly.cxx:470
 TH2Poly.cxx:471
 TH2Poly.cxx:472
 TH2Poly.cxx:473
 TH2Poly.cxx:474
 TH2Poly.cxx:475
 TH2Poly.cxx:476
 TH2Poly.cxx:477
 TH2Poly.cxx:478
 TH2Poly.cxx:479
 TH2Poly.cxx:480
 TH2Poly.cxx:481
 TH2Poly.cxx:482
 TH2Poly.cxx:483
 TH2Poly.cxx:484
 TH2Poly.cxx:485
 TH2Poly.cxx:486
 TH2Poly.cxx:487
 TH2Poly.cxx:488
 TH2Poly.cxx:489
 TH2Poly.cxx:490
 TH2Poly.cxx:491
 TH2Poly.cxx:492
 TH2Poly.cxx:493
 TH2Poly.cxx:494
 TH2Poly.cxx:495
 TH2Poly.cxx:496
 TH2Poly.cxx:497
 TH2Poly.cxx:498
 TH2Poly.cxx:499
 TH2Poly.cxx:500
 TH2Poly.cxx:501
 TH2Poly.cxx:502
 TH2Poly.cxx:503
 TH2Poly.cxx:504
 TH2Poly.cxx:505
 TH2Poly.cxx:506
 TH2Poly.cxx:507
 TH2Poly.cxx:508
 TH2Poly.cxx:509
 TH2Poly.cxx:510
 TH2Poly.cxx:511
 TH2Poly.cxx:512
 TH2Poly.cxx:513
 TH2Poly.cxx:514
 TH2Poly.cxx:515
 TH2Poly.cxx:516
 TH2Poly.cxx:517
 TH2Poly.cxx:518
 TH2Poly.cxx:519
 TH2Poly.cxx:520
 TH2Poly.cxx:521
 TH2Poly.cxx:522
 TH2Poly.cxx:523
 TH2Poly.cxx:524
 TH2Poly.cxx:525
 TH2Poly.cxx:526
 TH2Poly.cxx:527
 TH2Poly.cxx:528
 TH2Poly.cxx:529
 TH2Poly.cxx:530
 TH2Poly.cxx:531
 TH2Poly.cxx:532
 TH2Poly.cxx:533
 TH2Poly.cxx:534
 TH2Poly.cxx:535
 TH2Poly.cxx:536
 TH2Poly.cxx:537
 TH2Poly.cxx:538
 TH2Poly.cxx:539
 TH2Poly.cxx:540
 TH2Poly.cxx:541
 TH2Poly.cxx:542
 TH2Poly.cxx:543
 TH2Poly.cxx:544
 TH2Poly.cxx:545
 TH2Poly.cxx:546
 TH2Poly.cxx:547
 TH2Poly.cxx:548
 TH2Poly.cxx:549
 TH2Poly.cxx:550
 TH2Poly.cxx:551
 TH2Poly.cxx:552
 TH2Poly.cxx:553
 TH2Poly.cxx:554
 TH2Poly.cxx:555
 TH2Poly.cxx:556
 TH2Poly.cxx:557
 TH2Poly.cxx:558
 TH2Poly.cxx:559
 TH2Poly.cxx:560
 TH2Poly.cxx:561
 TH2Poly.cxx:562
 TH2Poly.cxx:563
 TH2Poly.cxx:564
 TH2Poly.cxx:565
 TH2Poly.cxx:566
 TH2Poly.cxx:567
 TH2Poly.cxx:568
 TH2Poly.cxx:569
 TH2Poly.cxx:570
 TH2Poly.cxx:571
 TH2Poly.cxx:572
 TH2Poly.cxx:573
 TH2Poly.cxx:574
 TH2Poly.cxx:575
 TH2Poly.cxx:576
 TH2Poly.cxx:577
 TH2Poly.cxx:578
 TH2Poly.cxx:579
 TH2Poly.cxx:580
 TH2Poly.cxx:581
 TH2Poly.cxx:582
 TH2Poly.cxx:583
 TH2Poly.cxx:584
 TH2Poly.cxx:585
 TH2Poly.cxx:586
 TH2Poly.cxx:587
 TH2Poly.cxx:588
 TH2Poly.cxx:589
 TH2Poly.cxx:590
 TH2Poly.cxx:591
 TH2Poly.cxx:592
 TH2Poly.cxx:593
 TH2Poly.cxx:594
 TH2Poly.cxx:595
 TH2Poly.cxx:596
 TH2Poly.cxx:597
 TH2Poly.cxx:598
 TH2Poly.cxx:599
 TH2Poly.cxx:600
 TH2Poly.cxx:601
 TH2Poly.cxx:602
 TH2Poly.cxx:603
 TH2Poly.cxx:604
 TH2Poly.cxx:605
 TH2Poly.cxx:606
 TH2Poly.cxx:607
 TH2Poly.cxx:608
 TH2Poly.cxx:609
 TH2Poly.cxx:610
 TH2Poly.cxx:611
 TH2Poly.cxx:612
 TH2Poly.cxx:613
 TH2Poly.cxx:614
 TH2Poly.cxx:615
 TH2Poly.cxx:616
 TH2Poly.cxx:617
 TH2Poly.cxx:618
 TH2Poly.cxx:619
 TH2Poly.cxx:620
 TH2Poly.cxx:621
 TH2Poly.cxx:622
 TH2Poly.cxx:623
 TH2Poly.cxx:624
 TH2Poly.cxx:625
 TH2Poly.cxx:626
 TH2Poly.cxx:627
 TH2Poly.cxx:628
 TH2Poly.cxx:629
 TH2Poly.cxx:630
 TH2Poly.cxx:631
 TH2Poly.cxx:632
 TH2Poly.cxx:633
 TH2Poly.cxx:634
 TH2Poly.cxx:635
 TH2Poly.cxx:636
 TH2Poly.cxx:637
 TH2Poly.cxx:638
 TH2Poly.cxx:639
 TH2Poly.cxx:640
 TH2Poly.cxx:641
 TH2Poly.cxx:642
 TH2Poly.cxx:643
 TH2Poly.cxx:644
 TH2Poly.cxx:645
 TH2Poly.cxx:646
 TH2Poly.cxx:647
 TH2Poly.cxx:648
 TH2Poly.cxx:649
 TH2Poly.cxx:650
 TH2Poly.cxx:651
 TH2Poly.cxx:652
 TH2Poly.cxx:653
 TH2Poly.cxx:654
 TH2Poly.cxx:655
 TH2Poly.cxx:656
 TH2Poly.cxx:657
 TH2Poly.cxx:658
 TH2Poly.cxx:659
 TH2Poly.cxx:660
 TH2Poly.cxx:661
 TH2Poly.cxx:662
 TH2Poly.cxx:663
 TH2Poly.cxx:664
 TH2Poly.cxx:665
 TH2Poly.cxx:666
 TH2Poly.cxx:667
 TH2Poly.cxx:668
 TH2Poly.cxx:669
 TH2Poly.cxx:670
 TH2Poly.cxx:671
 TH2Poly.cxx:672
 TH2Poly.cxx:673
 TH2Poly.cxx:674
 TH2Poly.cxx:675
 TH2Poly.cxx:676
 TH2Poly.cxx:677
 TH2Poly.cxx:678
 TH2Poly.cxx:679
 TH2Poly.cxx:680
 TH2Poly.cxx:681
 TH2Poly.cxx:682
 TH2Poly.cxx:683
 TH2Poly.cxx:684
 TH2Poly.cxx:685
 TH2Poly.cxx:686
 TH2Poly.cxx:687
 TH2Poly.cxx:688
 TH2Poly.cxx:689
 TH2Poly.cxx:690
 TH2Poly.cxx:691
 TH2Poly.cxx:692
 TH2Poly.cxx:693
 TH2Poly.cxx:694
 TH2Poly.cxx:695
 TH2Poly.cxx:696
 TH2Poly.cxx:697
 TH2Poly.cxx:698
 TH2Poly.cxx:699
 TH2Poly.cxx:700
 TH2Poly.cxx:701
 TH2Poly.cxx:702
 TH2Poly.cxx:703
 TH2Poly.cxx:704
 TH2Poly.cxx:705
 TH2Poly.cxx:706
 TH2Poly.cxx:707
 TH2Poly.cxx:708
 TH2Poly.cxx:709
 TH2Poly.cxx:710
 TH2Poly.cxx:711
 TH2Poly.cxx:712
 TH2Poly.cxx:713
 TH2Poly.cxx:714
 TH2Poly.cxx:715
 TH2Poly.cxx:716
 TH2Poly.cxx:717
 TH2Poly.cxx:718
 TH2Poly.cxx:719
 TH2Poly.cxx:720
 TH2Poly.cxx:721
 TH2Poly.cxx:722
 TH2Poly.cxx:723
 TH2Poly.cxx:724
 TH2Poly.cxx:725
 TH2Poly.cxx:726
 TH2Poly.cxx:727
 TH2Poly.cxx:728
 TH2Poly.cxx:729
 TH2Poly.cxx:730
 TH2Poly.cxx:731
 TH2Poly.cxx:732
 TH2Poly.cxx:733
 TH2Poly.cxx:734
 TH2Poly.cxx:735
 TH2Poly.cxx:736
 TH2Poly.cxx:737
 TH2Poly.cxx:738
 TH2Poly.cxx:739
 TH2Poly.cxx:740
 TH2Poly.cxx:741
 TH2Poly.cxx:742
 TH2Poly.cxx:743
 TH2Poly.cxx:744
 TH2Poly.cxx:745
 TH2Poly.cxx:746
 TH2Poly.cxx:747
 TH2Poly.cxx:748
 TH2Poly.cxx:749
 TH2Poly.cxx:750
 TH2Poly.cxx:751
 TH2Poly.cxx:752
 TH2Poly.cxx:753
 TH2Poly.cxx:754
 TH2Poly.cxx:755
 TH2Poly.cxx:756
 TH2Poly.cxx:757
 TH2Poly.cxx:758
 TH2Poly.cxx:759
 TH2Poly.cxx:760
 TH2Poly.cxx:761
 TH2Poly.cxx:762
 TH2Poly.cxx:763
 TH2Poly.cxx:764
 TH2Poly.cxx:765
 TH2Poly.cxx:766
 TH2Poly.cxx:767
 TH2Poly.cxx:768
 TH2Poly.cxx:769
 TH2Poly.cxx:770
 TH2Poly.cxx:771
 TH2Poly.cxx:772
 TH2Poly.cxx:773
 TH2Poly.cxx:774
 TH2Poly.cxx:775
 TH2Poly.cxx:776
 TH2Poly.cxx:777
 TH2Poly.cxx:778
 TH2Poly.cxx:779
 TH2Poly.cxx:780
 TH2Poly.cxx:781
 TH2Poly.cxx:782
 TH2Poly.cxx:783
 TH2Poly.cxx:784
 TH2Poly.cxx:785
 TH2Poly.cxx:786
 TH2Poly.cxx:787
 TH2Poly.cxx:788
 TH2Poly.cxx:789
 TH2Poly.cxx:790
 TH2Poly.cxx:791
 TH2Poly.cxx:792
 TH2Poly.cxx:793
 TH2Poly.cxx:794
 TH2Poly.cxx:795
 TH2Poly.cxx:796
 TH2Poly.cxx:797
 TH2Poly.cxx:798
 TH2Poly.cxx:799
 TH2Poly.cxx:800
 TH2Poly.cxx:801
 TH2Poly.cxx:802
 TH2Poly.cxx:803
 TH2Poly.cxx:804
 TH2Poly.cxx:805
 TH2Poly.cxx:806
 TH2Poly.cxx:807
 TH2Poly.cxx:808
 TH2Poly.cxx:809
 TH2Poly.cxx:810
 TH2Poly.cxx:811
 TH2Poly.cxx:812
 TH2Poly.cxx:813
 TH2Poly.cxx:814
 TH2Poly.cxx:815
 TH2Poly.cxx:816
 TH2Poly.cxx:817
 TH2Poly.cxx:818
 TH2Poly.cxx:819
 TH2Poly.cxx:820
 TH2Poly.cxx:821
 TH2Poly.cxx:822
 TH2Poly.cxx:823
 TH2Poly.cxx:824
 TH2Poly.cxx:825
 TH2Poly.cxx:826
 TH2Poly.cxx:827
 TH2Poly.cxx:828
 TH2Poly.cxx:829
 TH2Poly.cxx:830
 TH2Poly.cxx:831
 TH2Poly.cxx:832
 TH2Poly.cxx:833
 TH2Poly.cxx:834
 TH2Poly.cxx:835
 TH2Poly.cxx:836
 TH2Poly.cxx:837
 TH2Poly.cxx:838
 TH2Poly.cxx:839
 TH2Poly.cxx:840
 TH2Poly.cxx:841
 TH2Poly.cxx:842
 TH2Poly.cxx:843
 TH2Poly.cxx:844
 TH2Poly.cxx:845
 TH2Poly.cxx:846
 TH2Poly.cxx:847
 TH2Poly.cxx:848
 TH2Poly.cxx:849
 TH2Poly.cxx:850
 TH2Poly.cxx:851
 TH2Poly.cxx:852
 TH2Poly.cxx:853
 TH2Poly.cxx:854
 TH2Poly.cxx:855
 TH2Poly.cxx:856
 TH2Poly.cxx:857
 TH2Poly.cxx:858
 TH2Poly.cxx:859
 TH2Poly.cxx:860
 TH2Poly.cxx:861
 TH2Poly.cxx:862
 TH2Poly.cxx:863
 TH2Poly.cxx:864
 TH2Poly.cxx:865
 TH2Poly.cxx:866
 TH2Poly.cxx:867
 TH2Poly.cxx:868
 TH2Poly.cxx:869
 TH2Poly.cxx:870
 TH2Poly.cxx:871
 TH2Poly.cxx:872
 TH2Poly.cxx:873
 TH2Poly.cxx:874
 TH2Poly.cxx:875
 TH2Poly.cxx:876
 TH2Poly.cxx:877
 TH2Poly.cxx:878
 TH2Poly.cxx:879
 TH2Poly.cxx:880
 TH2Poly.cxx:881
 TH2Poly.cxx:882
 TH2Poly.cxx:883
 TH2Poly.cxx:884
 TH2Poly.cxx:885
 TH2Poly.cxx:886
 TH2Poly.cxx:887
 TH2Poly.cxx:888
 TH2Poly.cxx:889
 TH2Poly.cxx:890
 TH2Poly.cxx:891
 TH2Poly.cxx:892
 TH2Poly.cxx:893
 TH2Poly.cxx:894
 TH2Poly.cxx:895
 TH2Poly.cxx:896
 TH2Poly.cxx:897
 TH2Poly.cxx:898
 TH2Poly.cxx:899
 TH2Poly.cxx:900
 TH2Poly.cxx:901
 TH2Poly.cxx:902
 TH2Poly.cxx:903
 TH2Poly.cxx:904
 TH2Poly.cxx:905
 TH2Poly.cxx:906
 TH2Poly.cxx:907
 TH2Poly.cxx:908
 TH2Poly.cxx:909
 TH2Poly.cxx:910
 TH2Poly.cxx:911
 TH2Poly.cxx:912
 TH2Poly.cxx:913
 TH2Poly.cxx:914
 TH2Poly.cxx:915
 TH2Poly.cxx:916
 TH2Poly.cxx:917
 TH2Poly.cxx:918
 TH2Poly.cxx:919
 TH2Poly.cxx:920
 TH2Poly.cxx:921
 TH2Poly.cxx:922
 TH2Poly.cxx:923
 TH2Poly.cxx:924
 TH2Poly.cxx:925
 TH2Poly.cxx:926
 TH2Poly.cxx:927
 TH2Poly.cxx:928
 TH2Poly.cxx:929
 TH2Poly.cxx:930
 TH2Poly.cxx:931
 TH2Poly.cxx:932
 TH2Poly.cxx:933
 TH2Poly.cxx:934
 TH2Poly.cxx:935
 TH2Poly.cxx:936
 TH2Poly.cxx:937
 TH2Poly.cxx:938
 TH2Poly.cxx:939
 TH2Poly.cxx:940
 TH2Poly.cxx:941
 TH2Poly.cxx:942
 TH2Poly.cxx:943
 TH2Poly.cxx:944
 TH2Poly.cxx:945
 TH2Poly.cxx:946
 TH2Poly.cxx:947
 TH2Poly.cxx:948
 TH2Poly.cxx:949
 TH2Poly.cxx:950
 TH2Poly.cxx:951
 TH2Poly.cxx:952
 TH2Poly.cxx:953
 TH2Poly.cxx:954
 TH2Poly.cxx:955
 TH2Poly.cxx:956
 TH2Poly.cxx:957
 TH2Poly.cxx:958
 TH2Poly.cxx:959
 TH2Poly.cxx:960
 TH2Poly.cxx:961
 TH2Poly.cxx:962
 TH2Poly.cxx:963
 TH2Poly.cxx:964
 TH2Poly.cxx:965
 TH2Poly.cxx:966
 TH2Poly.cxx:967
 TH2Poly.cxx:968
 TH2Poly.cxx:969
 TH2Poly.cxx:970
 TH2Poly.cxx:971
 TH2Poly.cxx:972
 TH2Poly.cxx:973
 TH2Poly.cxx:974
 TH2Poly.cxx:975
 TH2Poly.cxx:976
 TH2Poly.cxx:977
 TH2Poly.cxx:978
 TH2Poly.cxx:979
 TH2Poly.cxx:980
 TH2Poly.cxx:981
 TH2Poly.cxx:982
 TH2Poly.cxx:983
 TH2Poly.cxx:984
 TH2Poly.cxx:985
 TH2Poly.cxx:986
 TH2Poly.cxx:987
 TH2Poly.cxx:988
 TH2Poly.cxx:989
 TH2Poly.cxx:990
 TH2Poly.cxx:991
 TH2Poly.cxx:992
 TH2Poly.cxx:993
 TH2Poly.cxx:994
 TH2Poly.cxx:995
 TH2Poly.cxx:996
 TH2Poly.cxx:997
 TH2Poly.cxx:998
 TH2Poly.cxx:999
 TH2Poly.cxx:1000
 TH2Poly.cxx:1001
 TH2Poly.cxx:1002
 TH2Poly.cxx:1003
 TH2Poly.cxx:1004
 TH2Poly.cxx:1005
 TH2Poly.cxx:1006
 TH2Poly.cxx:1007
 TH2Poly.cxx:1008
 TH2Poly.cxx:1009
 TH2Poly.cxx:1010
 TH2Poly.cxx:1011
 TH2Poly.cxx:1012
 TH2Poly.cxx:1013
 TH2Poly.cxx:1014
 TH2Poly.cxx:1015
 TH2Poly.cxx:1016
 TH2Poly.cxx:1017
 TH2Poly.cxx:1018
 TH2Poly.cxx:1019
 TH2Poly.cxx:1020
 TH2Poly.cxx:1021
 TH2Poly.cxx:1022
 TH2Poly.cxx:1023
 TH2Poly.cxx:1024
 TH2Poly.cxx:1025
 TH2Poly.cxx:1026
 TH2Poly.cxx:1027
 TH2Poly.cxx:1028
 TH2Poly.cxx:1029
 TH2Poly.cxx:1030
 TH2Poly.cxx:1031
 TH2Poly.cxx:1032
 TH2Poly.cxx:1033
 TH2Poly.cxx:1034
 TH2Poly.cxx:1035
 TH2Poly.cxx:1036
 TH2Poly.cxx:1037
 TH2Poly.cxx:1038
 TH2Poly.cxx:1039
 TH2Poly.cxx:1040
 TH2Poly.cxx:1041
 TH2Poly.cxx:1042
 TH2Poly.cxx:1043
 TH2Poly.cxx:1044
 TH2Poly.cxx:1045
 TH2Poly.cxx:1046
 TH2Poly.cxx:1047
 TH2Poly.cxx:1048
 TH2Poly.cxx:1049
 TH2Poly.cxx:1050
 TH2Poly.cxx:1051
 TH2Poly.cxx:1052
 TH2Poly.cxx:1053
 TH2Poly.cxx:1054
 TH2Poly.cxx:1055
 TH2Poly.cxx:1056
 TH2Poly.cxx:1057
 TH2Poly.cxx:1058
 TH2Poly.cxx:1059
 TH2Poly.cxx:1060
 TH2Poly.cxx:1061
 TH2Poly.cxx:1062
 TH2Poly.cxx:1063
 TH2Poly.cxx:1064
 TH2Poly.cxx:1065
 TH2Poly.cxx:1066
 TH2Poly.cxx:1067
 TH2Poly.cxx:1068
 TH2Poly.cxx:1069
 TH2Poly.cxx:1070
 TH2Poly.cxx:1071
 TH2Poly.cxx:1072
 TH2Poly.cxx:1073
 TH2Poly.cxx:1074
 TH2Poly.cxx:1075
 TH2Poly.cxx:1076
 TH2Poly.cxx:1077
 TH2Poly.cxx:1078
 TH2Poly.cxx:1079
 TH2Poly.cxx:1080
 TH2Poly.cxx:1081
 TH2Poly.cxx:1082
 TH2Poly.cxx:1083
 TH2Poly.cxx:1084
 TH2Poly.cxx:1085
 TH2Poly.cxx:1086
 TH2Poly.cxx:1087
 TH2Poly.cxx:1088
 TH2Poly.cxx:1089
 TH2Poly.cxx:1090
 TH2Poly.cxx:1091
 TH2Poly.cxx:1092
 TH2Poly.cxx:1093
 TH2Poly.cxx:1094
 TH2Poly.cxx:1095
 TH2Poly.cxx:1096
 TH2Poly.cxx:1097
 TH2Poly.cxx:1098
 TH2Poly.cxx:1099
 TH2Poly.cxx:1100
 TH2Poly.cxx:1101
 TH2Poly.cxx:1102
 TH2Poly.cxx:1103
 TH2Poly.cxx:1104
 TH2Poly.cxx:1105
 TH2Poly.cxx:1106
 TH2Poly.cxx:1107
 TH2Poly.cxx:1108
 TH2Poly.cxx:1109
 TH2Poly.cxx:1110
 TH2Poly.cxx:1111
 TH2Poly.cxx:1112
 TH2Poly.cxx:1113
 TH2Poly.cxx:1114
 TH2Poly.cxx:1115
 TH2Poly.cxx:1116
 TH2Poly.cxx:1117
 TH2Poly.cxx:1118
 TH2Poly.cxx:1119
 TH2Poly.cxx:1120
 TH2Poly.cxx:1121
 TH2Poly.cxx:1122
 TH2Poly.cxx:1123
 TH2Poly.cxx:1124
 TH2Poly.cxx:1125
 TH2Poly.cxx:1126
 TH2Poly.cxx:1127
 TH2Poly.cxx:1128
 TH2Poly.cxx:1129
 TH2Poly.cxx:1130
 TH2Poly.cxx:1131
 TH2Poly.cxx:1132
 TH2Poly.cxx:1133
 TH2Poly.cxx:1134
 TH2Poly.cxx:1135
 TH2Poly.cxx:1136
 TH2Poly.cxx:1137
 TH2Poly.cxx:1138
 TH2Poly.cxx:1139
 TH2Poly.cxx:1140
 TH2Poly.cxx:1141
 TH2Poly.cxx:1142
 TH2Poly.cxx:1143
 TH2Poly.cxx:1144
 TH2Poly.cxx:1145
 TH2Poly.cxx:1146
 TH2Poly.cxx:1147
 TH2Poly.cxx:1148
 TH2Poly.cxx:1149
 TH2Poly.cxx:1150
 TH2Poly.cxx:1151
 TH2Poly.cxx:1152
 TH2Poly.cxx:1153
 TH2Poly.cxx:1154
 TH2Poly.cxx:1155
 TH2Poly.cxx:1156
 TH2Poly.cxx:1157
 TH2Poly.cxx:1158
 TH2Poly.cxx:1159
 TH2Poly.cxx:1160
 TH2Poly.cxx:1161
 TH2Poly.cxx:1162
 TH2Poly.cxx:1163
 TH2Poly.cxx:1164
 TH2Poly.cxx:1165
 TH2Poly.cxx:1166
 TH2Poly.cxx:1167
 TH2Poly.cxx:1168
 TH2Poly.cxx:1169
 TH2Poly.cxx:1170
 TH2Poly.cxx:1171
 TH2Poly.cxx:1172
 TH2Poly.cxx:1173
 TH2Poly.cxx:1174
 TH2Poly.cxx:1175
 TH2Poly.cxx:1176
 TH2Poly.cxx:1177
 TH2Poly.cxx:1178
 TH2Poly.cxx:1179
 TH2Poly.cxx:1180
 TH2Poly.cxx:1181
 TH2Poly.cxx:1182
 TH2Poly.cxx:1183
 TH2Poly.cxx:1184
 TH2Poly.cxx:1185
 TH2Poly.cxx:1186
 TH2Poly.cxx:1187
 TH2Poly.cxx:1188
 TH2Poly.cxx:1189
 TH2Poly.cxx:1190
 TH2Poly.cxx:1191
 TH2Poly.cxx:1192
 TH2Poly.cxx:1193
 TH2Poly.cxx:1194
 TH2Poly.cxx:1195
 TH2Poly.cxx:1196
 TH2Poly.cxx:1197
 TH2Poly.cxx:1198
 TH2Poly.cxx:1199
 TH2Poly.cxx:1200
 TH2Poly.cxx:1201
 TH2Poly.cxx:1202
 TH2Poly.cxx:1203
 TH2Poly.cxx:1204
 TH2Poly.cxx:1205
 TH2Poly.cxx:1206
 TH2Poly.cxx:1207
 TH2Poly.cxx:1208
 TH2Poly.cxx:1209
 TH2Poly.cxx:1210
 TH2Poly.cxx:1211
 TH2Poly.cxx:1212
 TH2Poly.cxx:1213
 TH2Poly.cxx:1214
 TH2Poly.cxx:1215
 TH2Poly.cxx:1216
 TH2Poly.cxx:1217
 TH2Poly.cxx:1218
 TH2Poly.cxx:1219
 TH2Poly.cxx:1220
 TH2Poly.cxx:1221
 TH2Poly.cxx:1222
 TH2Poly.cxx:1223
 TH2Poly.cxx:1224
 TH2Poly.cxx:1225
 TH2Poly.cxx:1226
 TH2Poly.cxx:1227
 TH2Poly.cxx:1228
 TH2Poly.cxx:1229
 TH2Poly.cxx:1230
 TH2Poly.cxx:1231
 TH2Poly.cxx:1232
 TH2Poly.cxx:1233
 TH2Poly.cxx:1234
 TH2Poly.cxx:1235
 TH2Poly.cxx:1236
 TH2Poly.cxx:1237
 TH2Poly.cxx:1238
 TH2Poly.cxx:1239
 TH2Poly.cxx:1240
 TH2Poly.cxx:1241
 TH2Poly.cxx:1242
 TH2Poly.cxx:1243
 TH2Poly.cxx:1244
 TH2Poly.cxx:1245
 TH2Poly.cxx:1246
 TH2Poly.cxx:1247
 TH2Poly.cxx:1248
 TH2Poly.cxx:1249
 TH2Poly.cxx:1250
 TH2Poly.cxx:1251
 TH2Poly.cxx:1252
 TH2Poly.cxx:1253
 TH2Poly.cxx:1254
 TH2Poly.cxx:1255
 TH2Poly.cxx:1256
 TH2Poly.cxx:1257
 TH2Poly.cxx:1258
 TH2Poly.cxx:1259
 TH2Poly.cxx:1260
 TH2Poly.cxx:1261
 TH2Poly.cxx:1262
 TH2Poly.cxx:1263
 TH2Poly.cxx:1264
 TH2Poly.cxx:1265
 TH2Poly.cxx:1266
 TH2Poly.cxx:1267
 TH2Poly.cxx:1268
 TH2Poly.cxx:1269
 TH2Poly.cxx:1270
 TH2Poly.cxx:1271
 TH2Poly.cxx:1272
 TH2Poly.cxx:1273
 TH2Poly.cxx:1274
 TH2Poly.cxx:1275
 TH2Poly.cxx:1276
 TH2Poly.cxx:1277
 TH2Poly.cxx:1278
 TH2Poly.cxx:1279
 TH2Poly.cxx:1280
 TH2Poly.cxx:1281
 TH2Poly.cxx:1282
 TH2Poly.cxx:1283
 TH2Poly.cxx:1284
 TH2Poly.cxx:1285
 TH2Poly.cxx:1286
 TH2Poly.cxx:1287
 TH2Poly.cxx:1288
 TH2Poly.cxx:1289
 TH2Poly.cxx:1290
 TH2Poly.cxx:1291
 TH2Poly.cxx:1292
 TH2Poly.cxx:1293
 TH2Poly.cxx:1294
 TH2Poly.cxx:1295
 TH2Poly.cxx:1296
 TH2Poly.cxx:1297
 TH2Poly.cxx:1298
 TH2Poly.cxx:1299
 TH2Poly.cxx:1300
 TH2Poly.cxx:1301
 TH2Poly.cxx:1302
 TH2Poly.cxx:1303
 TH2Poly.cxx:1304
 TH2Poly.cxx:1305
 TH2Poly.cxx:1306
 TH2Poly.cxx:1307
 TH2Poly.cxx:1308
 TH2Poly.cxx:1309
 TH2Poly.cxx:1310
 TH2Poly.cxx:1311
 TH2Poly.cxx:1312
 TH2Poly.cxx:1313
 TH2Poly.cxx:1314
 TH2Poly.cxx:1315
 TH2Poly.cxx:1316
 TH2Poly.cxx:1317
 TH2Poly.cxx:1318
 TH2Poly.cxx:1319
 TH2Poly.cxx:1320
 TH2Poly.cxx:1321
 TH2Poly.cxx:1322
 TH2Poly.cxx:1323
 TH2Poly.cxx:1324
 TH2Poly.cxx:1325
 TH2Poly.cxx:1326
 TH2Poly.cxx:1327
 TH2Poly.cxx:1328
 TH2Poly.cxx:1329
 TH2Poly.cxx:1330
 TH2Poly.cxx:1331
 TH2Poly.cxx:1332
 TH2Poly.cxx:1333
 TH2Poly.cxx:1334
 TH2Poly.cxx:1335
 TH2Poly.cxx:1336
 TH2Poly.cxx:1337
 TH2Poly.cxx:1338
 TH2Poly.cxx:1339
 TH2Poly.cxx:1340
 TH2Poly.cxx:1341
 TH2Poly.cxx:1342
 TH2Poly.cxx:1343
 TH2Poly.cxx:1344
 TH2Poly.cxx:1345
 TH2Poly.cxx:1346
 TH2Poly.cxx:1347
 TH2Poly.cxx:1348
 TH2Poly.cxx:1349
 TH2Poly.cxx:1350
 TH2Poly.cxx:1351
 TH2Poly.cxx:1352
 TH2Poly.cxx:1353
 TH2Poly.cxx:1354
 TH2Poly.cxx:1355
 TH2Poly.cxx:1356
 TH2Poly.cxx:1357
 TH2Poly.cxx:1358
 TH2Poly.cxx:1359
 TH2Poly.cxx:1360
 TH2Poly.cxx:1361
 TH2Poly.cxx:1362
 TH2Poly.cxx:1363
 TH2Poly.cxx:1364
 TH2Poly.cxx:1365
 TH2Poly.cxx:1366
 TH2Poly.cxx:1367
 TH2Poly.cxx:1368
 TH2Poly.cxx:1369
 TH2Poly.cxx:1370
 TH2Poly.cxx:1371
 TH2Poly.cxx:1372
 TH2Poly.cxx:1373
 TH2Poly.cxx:1374
 TH2Poly.cxx:1375
 TH2Poly.cxx:1376
 TH2Poly.cxx:1377
 TH2Poly.cxx:1378
 TH2Poly.cxx:1379
 TH2Poly.cxx:1380
 TH2Poly.cxx:1381
 TH2Poly.cxx:1382
 TH2Poly.cxx:1383
 TH2Poly.cxx:1384
 TH2Poly.cxx:1385
 TH2Poly.cxx:1386
 TH2Poly.cxx:1387
 TH2Poly.cxx:1388
 TH2Poly.cxx:1389
 TH2Poly.cxx:1390
 TH2Poly.cxx:1391
 TH2Poly.cxx:1392
 TH2Poly.cxx:1393
 TH2Poly.cxx:1394
 TH2Poly.cxx:1395
 TH2Poly.cxx:1396
 TH2Poly.cxx:1397
 TH2Poly.cxx:1398
 TH2Poly.cxx:1399
 TH2Poly.cxx:1400
 TH2Poly.cxx:1401
 TH2Poly.cxx:1402
 TH2Poly.cxx:1403
 TH2Poly.cxx:1404
 TH2Poly.cxx:1405
 TH2Poly.cxx:1406
 TH2Poly.cxx:1407
 TH2Poly.cxx:1408
 TH2Poly.cxx:1409
 TH2Poly.cxx:1410
 TH2Poly.cxx:1411
 TH2Poly.cxx:1412
 TH2Poly.cxx:1413
 TH2Poly.cxx:1414
 TH2Poly.cxx:1415
 TH2Poly.cxx:1416
 TH2Poly.cxx:1417
 TH2Poly.cxx:1418
 TH2Poly.cxx:1419
 TH2Poly.cxx:1420
 TH2Poly.cxx:1421
 TH2Poly.cxx:1422
 TH2Poly.cxx:1423
 TH2Poly.cxx:1424
 TH2Poly.cxx:1425
 TH2Poly.cxx:1426
 TH2Poly.cxx:1427
 TH2Poly.cxx:1428
 TH2Poly.cxx:1429
 TH2Poly.cxx:1430
 TH2Poly.cxx:1431
 TH2Poly.cxx:1432
 TH2Poly.cxx:1433
 TH2Poly.cxx:1434
 TH2Poly.cxx:1435
 TH2Poly.cxx:1436
 TH2Poly.cxx:1437
 TH2Poly.cxx:1438
 TH2Poly.cxx:1439
 TH2Poly.cxx:1440
 TH2Poly.cxx:1441
 TH2Poly.cxx:1442
 TH2Poly.cxx:1443
 TH2Poly.cxx:1444
 TH2Poly.cxx:1445
 TH2Poly.cxx:1446
 TH2Poly.cxx:1447
 TH2Poly.cxx:1448
 TH2Poly.cxx:1449
 TH2Poly.cxx:1450
 TH2Poly.cxx:1451
 TH2Poly.cxx:1452
 TH2Poly.cxx:1453
 TH2Poly.cxx:1454
 TH2Poly.cxx:1455
 TH2Poly.cxx:1456
 TH2Poly.cxx:1457
 TH2Poly.cxx:1458
 TH2Poly.cxx:1459
 TH2Poly.cxx:1460
 TH2Poly.cxx:1461
 TH2Poly.cxx:1462
 TH2Poly.cxx:1463
 TH2Poly.cxx:1464
 TH2Poly.cxx:1465
 TH2Poly.cxx:1466
 TH2Poly.cxx:1467
 TH2Poly.cxx:1468
 TH2Poly.cxx:1469
 TH2Poly.cxx:1470
 TH2Poly.cxx:1471
 TH2Poly.cxx:1472
 TH2Poly.cxx:1473
 TH2Poly.cxx:1474
 TH2Poly.cxx:1475
 TH2Poly.cxx:1476
 TH2Poly.cxx:1477
 TH2Poly.cxx:1478
 TH2Poly.cxx:1479
 TH2Poly.cxx:1480
 TH2Poly.cxx:1481
 TH2Poly.cxx:1482
 TH2Poly.cxx:1483
 TH2Poly.cxx:1484
 TH2Poly.cxx:1485
 TH2Poly.cxx:1486
 TH2Poly.cxx:1487
 TH2Poly.cxx:1488
 TH2Poly.cxx:1489