// @(#)root/hist:$Id$ // Author: Rene Brun 26/12/94 /************************************************************************* * 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 <stdlib.h> #include <string.h> #include <stdio.h> #include <ctype.h> #include "Riostream.h" #include "TROOT.h" #include "TClass.h" #include "TMath.h" #include "THashList.h" #include "TH1.h" #include "TH2.h" #include "TF2.h" #include "TF3.h" #include "TPluginManager.h" #include "TVirtualPad.h" #include "TRandom.h" #include "TVirtualFitter.h" #include "THLimitsFinder.h" #include "TProfile.h" #include "TStyle.h" #include "TVectorF.h" #include "TVectorD.h" #include "TBrowser.h" #include "TObjString.h" #include "TError.h" #include "TVirtualHistPainter.h" #include "TVirtualFFT.h" #include "TSystem.h" #include "HFitInterface.h" #include "Fit/DataRange.h" #include "Fit/BinData.h" #include "Math/GoFTest.h" #include "Math/MinimizerOptions.h" #include "Math/QuantFuncMathCore.h" //______________________________________________________________________________ /* Begin_Html <center><h2>The Histogram classes</h2></center> ROOT supports the following histogram types: <ul> <li>1-D histograms: <ul> <li>TH1C : histograms with one byte per channel. Maximum bin content = 127 <li>TH1S : histograms with one short per channel. Maximum bin content = 32767 <li>TH1I : histograms with one int per channel. Maximum bin content = 2147483647 <li>TH1F : histograms with one float per channel. Maximum precision 7 digits <li>TH1D : histograms with one double per channel. Maximum precision 14 digits </ul> <li>2-D histograms: <ul> <li>TH2C : histograms with one byte per channel. Maximum bin content = 127 <li>TH2S : histograms with one short per channel. Maximum bin content = 32767 <li>TH2I : histograms with one int per channel. Maximum bin content = 2147483647 <li>TH2F : histograms with one float per channel. Maximum precision 7 digits <li>TH2D : histograms with one double per channel. Maximum precision 14 digits </ul> <li>3-D histograms: <ul> <li>TH3C : histograms with one byte per channel. Maximum bin content = 127 <li>TH3S : histograms with one short per channel. Maximum bin content = 32767 <li>TH3I : histograms with one int per channel. Maximum bin content = 2147483647 <li>TH3F : histograms with one float per channel. Maximum precision 7 digits <li>TH3D : histograms with one double per channel. Maximum precision 14 digits </ul> <li>Profile histograms: See classes TProfile, TProfile2D and TProfile3D. Profile histograms are used to display the mean value of Y and its RMS for each bin in X. Profile histograms are in many cases an elegant replacement of two-dimensional histograms : the inter-relation of two measured quantities X and Y can always be visualized by a two-dimensional histogram or scatter-plot; If Y is an unknown (but single-valued) approximate function of X, this function is displayed by a profile histogram with much better precision than by a scatter-plot. </ul> All histogram classes are derived from the base class TH1 <pre> TH1 ^ | | | ----------------------------------------------------------- | | | | | | | | | TH1C TH1S TH1I TH1F TH1D | | | | | | | TH2 TProfile | | | | | ---------------------------------- | | | | | | | TH2C TH2S TH2I TH2F TH2D | | TH3 | | TProfile2D | ------------------------------------- | | | | | TH3C TH3S TH3I TH3F TH3D | | TProfile3D The TH*C classes also inherit from the array class TArrayC. The TH*S classes also inherit from the array class TArrayS. The TH*I classes also inherit from the array class TArrayI. The TH*F classes also inherit from the array class TArrayF. The TH*D classes also inherit from the array class TArrayD. </pre> <h4>Creating histograms</h4> <p> Histograms are created by invoking one of the constructors, e.g. <pre> TH1F *h1 = new TH1F("h1", "h1 title", 100, 0, 4.4); TH2F *h2 = new TH2F("h2", "h2 title", 40, 0, 4, 30, -3, 3); </pre> <p> Histograms may also be created by: <ul> <li> calling the Clone function, see below <li> making a projection from a 2-D or 3-D histogram, see below <li> reading an histogram from a file </ul> <p> When an histogram is created, a reference to it is automatically added to the list of in-memory objects for the current file or directory. This default behaviour can be changed by: <pre> h->SetDirectory(0); for the current histogram h TH1::AddDirectory(kFALSE); sets a global switch disabling the reference </pre> When the histogram is deleted, the reference to it is removed from the list of objects in memory. When a file is closed, all histograms in memory associated with this file are automatically deleted. <h4>Fix or variable bin size</h4> All histogram types support either fix or variable bin sizes. 2-D histograms may have fix size bins along X and variable size bins along Y or vice-versa. The functions to fill, manipulate, draw or access histograms are identical in both cases. <p> Each histogram always contains 3 objects TAxis: fXaxis, fYaxis and fZaxis To access the axis parameters, do: <pre> TAxis *xaxis = h->GetXaxis(); etc. Double_t binCenter = xaxis->GetBinCenter(bin), etc. </pre> See class TAxis for a description of all the access functions. The axis range is always stored internally in double precision. <h4>Convention for numbering bins</h4> For all histogram types: nbins, xlow, xup <pre> bin = 0; underflow bin bin = 1; first bin with low-edge xlow INCLUDED bin = nbins; last bin with upper-edge xup EXCLUDED bin = nbins+1; overflow bin </pre> <p> In case of 2-D or 3-D histograms, a "global bin" number is defined. For example, assuming a 3-D histogram with (binx, biny, binz), the function <pre> Int_t gbin = h->GetBin(binx, biny, binz); </pre> returns a global/linearized gbin number. This global gbin is useful to access the bin content/error information independently of the dimension. Note that to access the information other than bin content and errors one should use the TAxis object directly with e.g.: <pre> Double_t xcenter = h3->GetZaxis()->GetBinCenter(27); </pre> returns the center along z of bin number 27 (not the global bin) in the 3-D histogram h3. <h4>Alphanumeric Bin Labels</h4> By default, an histogram axis is drawn with its numeric bin labels. One can specify alphanumeric labels instead with: <ul> <li> call TAxis::SetBinLabel(bin, label); This can always be done before or after filling. When the histogram is drawn, bin labels will be automatically drawn. See example in $ROOTSYS/tutorials/graphs/labels1.C, labels2.C <li> call to a Fill function with one of the arguments being a string, e.g. <pre> hist1->Fill(somename, weigth); hist2->Fill(x, somename, weight); hist2->Fill(somename, y, weight); hist2->Fill(somenamex, somenamey, weight); </pre> See example in $ROOTSYS/tutorials/hist/hlabels1.C, hlabels2.C <li> via TTree::Draw. see for example $ROOTSYS/tutorials/tree/cernstaff.C <pre> tree.Draw("Nation::Division"); </pre> where "Nation" and "Division" are two branches of a Tree. </ul> <p> When using the options 2 or 3 above, the labels are automatically added to the list (THashList) of labels for a given axis. By default, an axis is drawn with the order of bins corresponding to the filling sequence. It is possible to reorder the axis <ul> <li>alphabetically <li>by increasing or decreasing values </ul> <p> The reordering can be triggered via the TAxis context menu by selecting the menu item "LabelsOption" or by calling directly TH1::LabelsOption(option, axis) where <ul> <li>axis may be "X", "Y" or "Z" <li>option may be: <ul> <li>"a" sort by alphabetic order <li>">" sort by decreasing values <li>"<" sort by increasing values <li>"h" draw labels horizontal <li>"v" draw labels vertical <li>"u" draw labels up (end of label right adjusted) <li>"d" draw labels down (start of label left adjusted) </ul> </ul> <p> When using the option 2 above, new labels are added by doubling the current number of bins in case one label does not exist yet. When the Filling is terminated, it is possible to trim the number of bins to match the number of active labels by calling <pre> TH1::LabelsDeflate(axis) with axis = "X", "Y" or "Z" </pre> This operation is automatic when using TTree::Draw. Once bin labels have been created, they become persistent if the histogram is written to a file or when generating the C++ code via SavePrimitive. <h4>Histograms with automatic bins</h4> When an histogram is created with an axis lower limit greater or equal to its upper limit, the SetBuffer is automatically called with an argument fBufferSize equal to fgBufferSize (default value=1000). fgBufferSize may be reset via the static function TH1::SetDefaultBufferSize. The axis limits will be automatically computed when the buffer will be full or when the function BufferEmpty is called. <h4>Filling histograms</h4> An histogram is typically filled with statements like: <pre> h1->Fill(x); h1->Fill(x, w); //fill with weight h2->Fill(x, y) h2->Fill(x, y, w) h3->Fill(x, y, z) h3->Fill(x, y, z, w) </pre> or via one of the Fill functions accepting names described above. The Fill functions compute the bin number corresponding to the given x, y or z argument and increment this bin by the given weight. The Fill functions return the bin number for 1-D histograms or global bin number for 2-D and 3-D histograms. <p> If TH1::Sumw2 has been called before filling, the sum of squares of weights is also stored. One can also increment directly a bin number via TH1::AddBinContent or replace the existing content via TH1::SetBinContent. To access the bin content of a given bin, do: <pre> Double_t binContent = h->GetBinContent(bin); </pre> <p> By default, the bin number is computed using the current axis ranges. If the automatic binning option has been set via <pre> h->SetBit(TH1::kCanRebin); </pre> then, the Fill Function will automatically extend the axis range to accomodate the new value specified in the Fill argument. The method used is to double the bin size until the new value fits in the range, merging bins two by two. This automatic binning options is extensively used by the TTree::Draw function when histogramming Tree variables with an unknown range. <p> This automatic binning option is supported for 1-D, 2-D and 3-D histograms. During filling, some statistics parameters are incremented to compute the mean value and Root Mean Square with the maximum precision. <p> In case of histograms of type TH1C, TH1S, TH2C, TH2S, TH3C, TH3S a check is made that the bin contents do not exceed the maximum positive capacity (127 or 32767). Histograms of all types may have positive or/and negative bin contents. <h4>Rebinning</h4> At any time, an histogram can be rebinned via TH1::Rebin. This function returns a new histogram with the rebinned contents. If bin errors were stored, they are recomputed during the rebinning. <h4>Associated errors</h4> By default, for each bin, the sum of weights is computed at fill time. One can also call TH1::Sumw2 to force the storage and computation of the sum of the square of weights per bin. If Sumw2 has been called, the error per bin is computed as the sqrt(sum of squares of weights), otherwise the error is set equal to the sqrt(bin content). To return the error for a given bin number, do: <pre> Double_t error = h->GetBinError(bin); </pre> <h4>Associated functions</h4> One or more object (typically a TF1*) can be added to the list of functions (fFunctions) associated to each histogram. When TH1::Fit is invoked, the fitted function is added to this list. Given an histogram h, one can retrieve an associated function with: <pre> TF1 *myfunc = h->GetFunction("myfunc"); </pre> <h4>Operations on histograms</h4> Many types of operations are supported on histograms or between histograms <ul> <li> Addition of an histogram to the current histogram. <li> Additions of two histograms with coefficients and storage into the current histogram. <li> Multiplications and Divisions are supported in the same way as additions. <li> The Add, Divide and Multiply functions also exist to add, divide or multiply an histogram by a function. </ul> If an histogram has associated error bars (TH1::Sumw2 has been called), the resulting error bars are also computed assuming independent histograms. In case of divisions, Binomial errors are also supported. One can mark a histogram to be an "average" histogram by setting its bit kIsAverage via myhist.SetBit(TH1::kIsAverage); When adding (see TH1::Add) average histograms, the histograms are averaged and not summed. <h4>Fitting histograms</h4> Histograms (1-D, 2-D, 3-D and Profiles) can be fitted with a user specified function via TH1::Fit. When an histogram is fitted, the resulting function with its parameters is added to the list of functions of this histogram. If the histogram is made persistent, the list of associated functions is also persistent. Given a pointer (see above) to an associated function myfunc, one can retrieve the function/fit parameters with calls such as: <pre> Double_t chi2 = myfunc->GetChisquare(); Double_t par0 = myfunc->GetParameter(0); value of 1st parameter Double_t err0 = myfunc->GetParError(0); error on first parameter </pre> <h4>Projections of histograms</h4> <p> One can: <ul> <li> make a 1-D projection of a 2-D histogram or Profile see functions TH2::ProjectionX,Y, TH2::ProfileX,Y, TProfile::ProjectionX <li> make a 1-D, 2-D or profile out of a 3-D histogram see functions TH3::ProjectionZ, TH3::Project3D. </ul> <p> One can fit these projections via: <pre> TH2::FitSlicesX,Y, TH3::FitSlicesZ. </pre> <h4>Random Numbers and histograms</h4> TH1::FillRandom can be used to randomly fill an histogram using the contents of an existing TF1 function or another TH1 histogram (for all dimensions). <p> For example the following two statements create and fill an histogram 10000 times with a default gaussian distribution of mean 0 and sigma 1: <pre> TH1F h1("h1", "histo from a gaussian", 100, -3, 3); h1.FillRandom("gaus", 10000); </pre> TH1::GetRandom can be used to return a random number distributed according the contents of an histogram. <h4>Making a copy of an histogram</h4> Like for any other ROOT object derived from TObject, one can use the Clone() function. This makes an identical copy of the original histogram including all associated errors and functions, e.g.: <pre> TH1F *hnew = (TH1F*)h->Clone("hnew"); </pre> <h4>Normalizing histograms</h4> One can scale an histogram such that the bins integral is equal to the normalization parameter via TH1::Scale(Double_t norm), where norm is the desired normalization divided by the integral of the histogram. <h4>Drawing histograms</h4> Histograms are drawn via the THistPainter class. Each histogram has a pointer to its own painter (to be usable in a multithreaded program). Many drawing options are supported. See THistPainter::Paint() for more details. <p> The same histogram can be drawn with different options in different pads. When an histogram drawn in a pad is deleted, the histogram is automatically removed from the pad or pads where it was drawn. If an histogram is drawn in a pad, then filled again, the new status of the histogram will be automatically shown in the pad next time the pad is updated. One does not need to redraw the histogram. To draw the current version of an histogram in a pad, one can use <pre> h->DrawCopy(); </pre> This makes a clone (see Clone below) of the histogram. Once the clone is drawn, the original histogram may be modified or deleted without affecting the aspect of the clone. <p> One can use TH1::SetMaximum() and TH1::SetMinimum() to force a particular value for the maximum or the minimum scale on the plot. (For 1-D histograms this means the y-axis, while for 2-D histograms these functions affect the z-axis). <p> TH1::UseCurrentStyle() can be used to change all histogram graphics attributes to correspond to the current selected style. This function must be called for each histogram. In case one reads and draws many histograms from a file, one can force the histograms to inherit automatically the current graphics style by calling before gROOT->ForceStyle(). <h4>Setting Drawing histogram contour levels (2-D hists only)</h4> By default contours are automatically generated at equidistant intervals. A default value of 20 levels is used. This can be modified via TH1::SetContour() or TH1::SetContourLevel(). the contours level info is used by the drawing options "cont", "surf", and "lego". <h4>Setting histogram graphics attributes</h4> The histogram classes inherit from the attribute classes: TAttLine, TAttFill, and TAttMarker. See the member functions of these classes for the list of options. <h4>Giving titles to the X, Y and Z axis</h4> <pre> h->GetXaxis()->SetTitle("X axis title"); h->GetYaxis()->SetTitle("Y axis title"); </pre> The histogram title and the axis titles can be any TLatex string. The titles are part of the persistent histogram. It is also possible to specify the histogram title and the axis titles at creation time. These titles can be given in the "title" parameter. They must be separated by ";": <pre> TH1F* h=new TH1F("h", "Histogram title;X Axis;Y Axis;Z Axis", 100, 0, 1); </pre> Any title can be omitted: <pre> TH1F* h=new TH1F("h", "Histogram title;;Y Axis", 100, 0, 1); TH1F* h=new TH1F("h", ";;Y Axis", 100, 0, 1); </pre> The method SetTitle has the same syntax: <pre> </pre> h->SetTitle("Histogram title;Another X title Axis"); <h4>Saving/Reading histograms to/from a ROOT file</h4> The following statements create a ROOT file and store an histogram on the file. Because TH1 derives from TNamed, the key identifier on the file is the histogram name: <pre> TFile f("histos.root", "new"); TH1F h1("hgaus", "histo from a gaussian", 100, -3, 3); h1.FillRandom("gaus", 10000); h1->Write(); </pre> To read this histogram in another Root session, do: <pre> TFile f("histos.root"); TH1F *h = (TH1F*)f.Get("hgaus"); </pre> One can save all histograms in memory to the file by: <pre> file->Write(); </pre> <h4>Miscelaneous operations</h4> <pre> TH1::KolmogorovTest(): statistical test of compatibility in shape between two histograms TH1::Smooth() smooths the bin contents of a 1-d histogram TH1::Integral() returns the integral of bin contents in a given bin range TH1::GetMean(int axis) returns the mean value along axis TH1::GetRMS(int axis) returns the sigma distribution along axis TH1::GetEntries() returns the number of entries TH1::Reset() resets the bin contents and errors of an histogram </pre> End_Html */ TF1 *gF1=0; //left for back compatibility (use TVirtualFitter::GetUserFunc instead) Int_t TH1::fgBufferSize = 1000; Bool_t TH1::fgAddDirectory = kTRUE; Bool_t TH1::fgDefaultSumw2 = kFALSE; Bool_t TH1::fgStatOverflows= kFALSE; extern void H1InitGaus(); extern void H1InitExpo(); extern void H1InitPolynom(); extern void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a); extern void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail); extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b); // Internal exceptions for the CheckConsistency method class DifferentDimension: public std::exception {}; class DifferentNumberOfBins: public std::exception {}; class DifferentAxisLimits: public std::exception {}; class DifferentBinLimits: public std::exception {}; class DifferentLabels: public std::exception {}; ClassImp(TH1) //______________________________________________________________________________ TH1::TH1(): TNamed(), TAttLine(), TAttFill(), TAttMarker() { // -*-*-*-*-*-*-*-*-*Histogram default constructor*-*-*-*-*-*-*-*-*-*-*-*-* // ============================= fDirectory = 0; fFunctions = new TList; fNcells = 0; fIntegral = 0; fPainter = 0; fEntries = 0; fNormFactor = 0; fTsumw = fTsumw2=fTsumwx=fTsumwx2=0; fMaximum = -1111; fMinimum = -1111; fBufferSize = 0; fBuffer = 0; fBinStatErrOpt = kNormal; fXaxis.SetName("xaxis"); fYaxis.SetName("yaxis"); fZaxis.SetName("zaxis"); fXaxis.SetParent(this); fYaxis.SetParent(this); fZaxis.SetParent(this); UseCurrentStyle(); } //______________________________________________________________________________ TH1::~TH1() { // -*-*-*-*-*-*-*-*-*Histogram default destructor*-*-*-*-*-*-*-*-*-*-*-*-*-* // ============================ if (!TestBit(kNotDeleted)) { return; } delete[] fIntegral; fIntegral = 0; delete[] fBuffer; fBuffer = 0; if (fFunctions) { fFunctions->SetBit(kInvalidObject); TObject* obj = 0; //special logic to support the case where the same object is //added multiple times in fFunctions. //This case happens when the same object is added with different //drawing modes //In the loop below we must be careful with objects (eg TCutG) that may // have been added to the list of functions of several histograms //and may have been already deleted. while ((obj = fFunctions->First())) { while(fFunctions->Remove(obj)) { } if (!obj->TestBit(kNotDeleted)) { break; } delete obj; obj = 0; } delete fFunctions; fFunctions = 0; } if (fDirectory) { fDirectory->Remove(this); fDirectory = 0; } delete fPainter; fPainter = 0; } //______________________________________________________________________________ TH1::TH1(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker() { // -*-*-*-*-*-*-*Normal constructor for fix bin size histograms*-*-*-*-*-*-* // ============================================== // // Creates the main histogram structure: // name : name of histogram (avoid blanks) // title : histogram title // if title is of the form "stringt;stringx;stringy;stringz" // the histogram title is set to stringt, // the x axis title to stringy, the y axis title to stringy, etc. // nbins : number of bins // xlow : low edge of first bin // xup : upper edge of last bin (not included in last bin) // // When an histogram is created, it is automatically added to the list // of special objects in the current directory. // To find the pointer to this histogram in the current directory // by its name, do: // TH1F *h1 = (TH1F*)gDirectory->FindObject(name); // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Build(); if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; } fXaxis.Set(nbins,xlow,xup); fNcells = fXaxis.GetNbins()+2; } //______________________________________________________________________________ TH1::TH1(const char *name,const char *title,Int_t nbins,const Float_t *xbins) :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker() { // -*-*-*-*-*Normal constructor for variable bin size histograms*-*-*-*-*-*-* // =================================================== // // Creates the main histogram structure: // name : name of histogram (avoid blanks) // title : histogram title // if title is of the form "stringt;stringx;stringy;stringz" // the histogram title is set to stringt, // the x axis title to stringx, the y axis title to stringy, etc. // nbins : number of bins // xbins : array of low-edges for each bin // This is an array of size nbins+1 // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Build(); if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; } if (xbins) fXaxis.Set(nbins,xbins); else fXaxis.Set(nbins,0,1); fNcells = fXaxis.GetNbins()+2; } //______________________________________________________________________________ TH1::TH1(const char *name,const char *title,Int_t nbins,const Double_t *xbins) :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker() { // -*-*-*-*-*Normal constructor for variable bin size histograms*-*-*-*-*-*-* // =================================================== // // Creates the main histogram structure: // name : name of histogram (avoid blanks) // title : histogram title // if title is of the form "stringt;stringx;stringy;stringz" // the histogram title is set to stringt, // the x axis title to stringx, the y axis title to stringy, etc. // nbins : number of bins // xbins : array of low-edges for each bin // This is an array of size nbins+1 // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Build(); if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; } if (xbins) fXaxis.Set(nbins,xbins); else fXaxis.Set(nbins,0,1); fNcells = fXaxis.GetNbins()+2; } //______________________________________________________________________________ TH1::TH1(const TH1 &h) : TNamed(), TAttLine(), TAttFill(), TAttMarker() { // Copy constructor. // The list of functions is not copied. (Use Clone if needed) ((TH1&)h).Copy(*this); } //______________________________________________________________________________ Bool_t TH1::AddDirectoryStatus() { //static function: cannot be inlined on Windows/NT return fgAddDirectory; } //______________________________________________________________________________ void TH1::Browse(TBrowser *b) { // Browe the Histogram object. Draw(b ? b->GetDrawOption() : ""); gPad->Update(); } //______________________________________________________________________________ void TH1::Build() { // -*-*-*-*-*-*-*-*Creates histogram basic data structure*-*-*-*-*-*-*-*-*-* // ====================================== fDirectory = 0; fPainter = 0; fIntegral = 0; fEntries = 0; fNormFactor = 0; fTsumw = fTsumw2=fTsumwx=fTsumwx2=0; fMaximum = -1111; fMinimum = -1111; fBufferSize = 0; fBuffer = 0; fBinStatErrOpt = kNormal; fXaxis.SetName("xaxis"); fYaxis.SetName("yaxis"); fZaxis.SetName("zaxis"); fYaxis.Set(1,0.,1.); fZaxis.Set(1,0.,1.); fXaxis.SetParent(this); fYaxis.SetParent(this); fZaxis.SetParent(this); SetTitle(fTitle.Data()); fFunctions = new TList; UseCurrentStyle(); if (TH1::AddDirectoryStatus()) { fDirectory = gDirectory; if (fDirectory) { fDirectory->Append(this,kTRUE); } } } //______________________________________________________________________________ Bool_t TH1::Add(TF1 *f1, Double_t c1, Option_t *option) { // Performs the operation: this = this + c1*f1 // if errors are defined (see TH1::Sumw2), errors are also recalculated. // // By default, the function is computed at the centre of the bin. // if option "I" is specified (1-d histogram only), the integral of the // function in each bin is used instead of the value of the function at // the centre of the bin. // Only bins inside the function range are recomputed. // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Add // // The function return kFALSE if the Add operation failed if (!f1) { Error("Add","Attempt to add a non-existing function"); return kFALSE; } TString opt = option; opt.ToLower(); Bool_t integral = kFALSE; if (opt.Contains("i") && fDimension ==1) integral = kTRUE; Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); // - Add statistics Double_t s1[10]; Int_t i; for (i=0;i<10;i++) {s1[i] = 0;} PutStats(s1); SetMinimum(); SetMaximum(); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t cu=0; Double_t xx[3]; Double_t *params = 0; f1->InitArgs(xx,params); for (binz=0;binz<=nbinsz+1;binz++) { xx[2] = fZaxis.GetBinCenter(binz); for (biny=0;biny<=nbinsy+1;biny++) { xx[1] = fYaxis.GetBinCenter(biny); for (binx=0;binx<=nbinsx+1;binx++) { xx[0] = fXaxis.GetBinCenter(binx); if (!f1->IsInside(xx)) continue; TF1::RejectPoint(kFALSE); bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); if (integral) { xx[0] = fXaxis.GetBinLowEdge(binx); cu = c1*f1->EvalPar(xx); cu += c1*f1->Integral(fXaxis.GetBinLowEdge(binx),fXaxis.GetBinUpEdge(binx))*fXaxis.GetBinWidth(binx); } else { cu = c1*f1->EvalPar(xx); } if (TF1::RejectedPoint()) continue; Double_t error1 = GetBinError(bin); AddBinContent(bin,cu); if (fSumw2.fN) { //errors are unchanged: error on f1 assumed 0 fSumw2.fArray[bin] = error1*error1; } } } } return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Add(const TH1 *h1, Double_t c1) { // Performs the operation: this = this + c1*h1 // if errors are defined (see TH1::Sumw2), errors are also recalculated. // Note that if h1 has Sumw2 set, Sumw2 is automatically called for this // if not already set. // Note also that adding histogram with labels is not supported, histogram will be // added merging them by bin number independently of the labels. // For adding histogram with labels one should use TH1::Merge // // SPECIAL CASE (Average/Efficiency histograms) // For histograms representing averages or efficiencies, one should compute the average // of the two histograms and not the sum. One can mark a histogram to be an average // histogram by setting its bit kIsAverage with // myhist.SetBit(TH1::kIsAverage); // Note that the two histograms must have their kIsAverage bit set // // IMPORTANT NOTE1: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Add // // IMPORTANT NOTE2: if h1 has a normalisation factor, the normalisation factor // is used , ie this = this + c1*factor*h1 // Use the other TH1::Add function if you do not want this feature // // The function return kFALSE if the Add operation failed if (!h1) { Error("Add","Attempt to add a non-existing histogram"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); try { CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Add","Attempt to add histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Add","Attempt to add histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Add","Attempt to add histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Add","Attempt to add histograms with different labels"); } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 has Sumw2 set if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2(); // - Add statistics Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() ); // statistics can be preserbed only in case of positive coefficients // otherwise with negative c1 (histogram subtraction) one risks to get negative variances Bool_t resetStats = (c1 < 0); Double_t s1[kNstat] = {0}; Double_t s2[kNstat] = {0}; if (!resetStats) { // need to initialize to zero s1 and s2 since // GetStats fills only used elements depending on dimension and type GetStats(s1); h1->GetStats(s2); } SetMinimum(); SetMaximum(); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t cu; Double_t factor =1; if (h1->GetNormFactor() != 0) factor = h1->GetNormFactor()/h1->GetSumOfWeights();; for (binz=0;binz<=nbinsz+1;binz++) { for (biny=0;biny<=nbinsy+1;biny++) { for (binx=0;binx<=nbinsx+1;binx++) { bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); //special case where histograms have the kIsAverage bit set if (this->TestBit(kIsAverage) && h1->TestBit(kIsAverage)) { Double_t y1 = h1->GetBinContent(bin); Double_t y2 = this->GetBinContent(bin); Double_t e1 = h1->GetBinError(bin); Double_t e2 = this->GetBinError(bin); Double_t w1 = 1., w2 = 1.; // consider all special cases when bin errors are zero // see http://root.cern.ch/phpBB3//viewtopic.php?f=3&t=13299 if (e1 > 0 ) w1 = 1./(e1*e1); else if (h1->fSumw2.fN) { w1 = 1.E200; // use an arbitrary huge value if (y1 == 0) { // use an estimated error from the global histogram scale double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1; w1 = 1./(sf*sf); } } if (e2 > 0) w2 = 1./(e2*e2); else if (fSumw2.fN) { w2 = 1.E200; // use an arbitrary huge value if (y2 == 0) { // use an estimated error from the global histogram scale double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1; w2 = 1./(sf*sf); } } double y = (w1*y1 + w2*y2)/(w1 + w2); SetBinContent(bin, y); if (fSumw2.fN) { double err2 = 1./(w1 + w2); if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0 fSumw2.fArray[bin] = err2; } } //normal case of addition between histograms else { cu = c1*factor*h1->GetBinContent(bin); AddBinContent(bin,cu); if (fSumw2.fN) { Double_t e1 = factor*h1->GetBinError(bin); fSumw2.fArray[bin] += c1*c1*e1*e1; } } } } } // update statistics (do here to avoid changes by SetBinContent) if (resetStats) { // statistics need to be reset in case coefficient are negative ResetStats(); } else { for (Int_t i=0;i<kNstat;i++) { if (i == 1) s1[i] += c1*c1*s2[i]; else s1[i] += c1*s2[i]; } PutStats(s1); SetEntries(entries); } return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Add(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2) { // -*-*-*Replace contents of this histogram by the addition of h1 and h2*-*-* // =============================================================== // // this = c1*h1 + c2*h2 // if errors are defined (see TH1::Sumw2), errors are also recalculated // Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this // if not already set. // Note also that adding histogram with labels is not supported, histogram will be // added merging them by bin number independently of the labels. // For adding histogram ith labels one should use TH1::Merge // // SPECIAL CASE (Average/Efficiency histograms) // For histograms representing averages or efficiencies, one should compute the average // of the two histograms and not the sum. One can mark a histogram to be an average // histogram by setting its bit kIsAverage with // myhist.SetBit(TH1::kIsAverage); // Note that the two histograms must have their kIsAverage bit set // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Add // //ANOTHER SPECIAL CASE : h1 = h2 and c2 < 0 // do a scaling this = c1 * h1 / (bin Volume) // // The function returns kFALSE if the Add operation failed if (!h1 || !h2) { Error("Add","Attempt to add a non-existing histogram"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Bool_t normWidth = kFALSE; if (h1 == h2 && c2 < 0) {c2 = 0; normWidth = kTRUE;} Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); if (h1 != h2) { try { CheckConsistency(h1,h2); CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Add","Attempt to add histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Add","Attempt to add histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Add","Attempt to add histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Add","Attempt to add histograms with different labels"); } } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 or h2 have Sumw2 set if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2(); // - Add statistics Double_t nEntries = TMath::Abs( c1*h1->GetEntries() + c2*h2->GetEntries() ); // statistics can be preserved only in case of positive coefficients // otherwise with negative c1 (histogram subtraction) one risks to get negative variances // also in case of scaling with the width we cannot preserve the statistics Double_t s1[kNstat] = {0}; Double_t s2[kNstat] = {0}; Double_t s3[kNstat]; Bool_t resetStats = (c1*c2 < 0) || normWidth; if (!resetStats) { // need to initialize to zero s1 and s2 since // GetStats fills only used elements depending on dimension and type h1->GetStats(s1); h2->GetStats(s2); for (Int_t i=0;i<kNstat;i++) { if (i == 1) s3[i] = c1*c1*s1[i] + c2*c2*s2[i]; //else s3[i] = TMath::Abs(c1)*s1[i] + TMath::Abs(c2)*s2[i]; else s3[i] = c1*s1[i] + c2*s2[i]; } } SetMinimum(); SetMaximum(); // Reset the kCanRebin and time display option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! // we need to do for only X axis since only TH1x::SetBinContent resize the axis Bool_t canRebin = TestBit(kCanRebin); if (canRebin) ResetBit(kCanRebin); Bool_t timeDisplayX = fXaxis.GetTimeDisplay(); if (timeDisplayX) fXaxis.SetTimeDisplay(0); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t cu; for (binz=0;binz<=nbinsz+1;binz++) { Double_t wz = h1->GetZaxis()->GetBinWidth(binz); for (biny=0;biny<=nbinsy+1;biny++) { Double_t wy = h1->GetYaxis()->GetBinWidth(biny); for (binx=0;binx<=nbinsx+1;binx++) { Double_t wx = h1->GetXaxis()->GetBinWidth(binx); bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); //special case where histograms have the kIsAverage bit set if (h1->TestBit(kIsAverage) && h2->TestBit(kIsAverage)) { Double_t y1 = h1->GetBinContent(bin); Double_t y2 = h2->GetBinContent(bin); Double_t e1 = h1->GetBinError(bin); Double_t e2 = h2->GetBinError(bin); Double_t w1 = 1., w2 = 1.; // consider all special cases when bin errors are zero // see http://root.cern.ch/phpBB3//viewtopic.php?f=3&t=13299 if (e1 > 0 ) w1 = 1./(e1*e1); else if (h1->fSumw2.fN) { w1 = 1.E200; // use an arbitrary huge value if (y1 == 0 ) { // use an estimated error from the global histogram scale double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1; w1 = 1./(sf*sf); } } if (e2 > 0) w2 = 1./(e2*e2); else if (h2->fSumw2.fN) { w2 = 1.E200; // use an arbitrary huge value if (y2 == 0) { // use an estimated error from the global histogram scale double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1; w2 = 1./(sf*sf); } } double y = (w1*y1 + w2*y2)/(w1 + w2); SetBinContent(bin, y); if (fSumw2.fN) { double err2 = 1./(w1 + w2); if (err2 < 1.E-200) err2 = 0; // to remove arbitrary value when e1=0 AND e2=0 fSumw2.fArray[bin] = err2; } } // case of histogram Addition else { if (normWidth) { Double_t w = wx*wy*wz; cu = c1*h1->GetBinContent(bin)/w; SetBinContent(bin,cu); if (fSumw2.fN) { Double_t e1 = h1->GetBinError(bin)/w; fSumw2.fArray[bin] = c1*c1*e1*e1; } } else { cu = c1*h1->GetBinContent(bin)+ c2*h2->GetBinContent(bin); SetBinContent(bin,cu); if (fSumw2.fN) { Double_t e1 = h1->GetBinError(bin); Double_t e2 = h2->GetBinError(bin); fSumw2.fArray[bin] = c1*c1*e1*e1 + c2*c2*e2*e2; } } } } } } if (resetStats) { // statistics need to be reset in case coefficient are negative ResetStats(); } else { // update statistics (do here to avoid changes by SetBinContent) PutStats(s3); SetEntries(nEntries); } if (canRebin) SetBit(kCanRebin); if (timeDisplayX) fXaxis.SetTimeDisplay(1); return kTRUE; } //______________________________________________________________________________ void TH1::AddBinContent(Int_t) { // -*-*-*-*-*-*-*-*Increment bin content by 1*-*-*-*-*-*-*-*-*-*-*-*-*-* // ========================== AbstractMethod("AddBinContent"); } //______________________________________________________________________________ void TH1::AddBinContent(Int_t, Double_t) { // -*-*-*-*-*-*-*-*Increment bin content by a weight w*-*-*-*-*-*-*-*-*-*-* // =================================== AbstractMethod("AddBinContent"); } //______________________________________________________________________________ void TH1::AddDirectory(Bool_t add) { // Sets the flag controlling the automatic add of histograms in memory // // By default (fAddDirectory = kTRUE), histograms are automatically added // to the list of objects in memory. // Note that one histogram can be removed from its support directory // by calling h->SetDirectory(0) or h->SetDirectory(dir) to add it // to the list of objects in the directory dir. // // NOTE that this is a static function. To call it, use; // TH1::AddDirectory fgAddDirectory = add; } //______________________________________________________________________________ Int_t TH1::BufferEmpty(Int_t action) { // Fill histogram with all entries in the buffer. // action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint) // action = 0 histogram is reset and filled from the buffer. When the histogram is filled from the // buffer the value fBuffer[0] is set to a negative number (= - number of entries) // When calling with action == 0 the histogram is NOT refilled when fBuffer[0] is < 0 // While when calling with action = -1 the histogram is reset and ALWAYS refilled independently if // the histogram was filled before. This is needed when drawing the histogram // // action = 1 histogram is filled and buffer is deleted // The buffer is automatically deleted when filling the histogram and the entries is // larger than the buffer size // // do we need to compute the bin size? if (!fBuffer) return 0; Int_t nbentries = (Int_t)fBuffer[0]; // nbentries correspond to the number of entries of histogram if (nbentries == 0) return 0; if (nbentries < 0 && action == 0) return 0; // case histogram has been already filled from the buffer Double_t *buffer = fBuffer; if (nbentries < 0) { nbentries = -nbentries; // a reset might call BufferEmpty() giving an infinite loop // Protect it by setting fBuffer = 0 fBuffer=0; //do not reset the list of functions Reset("ICES"); fBuffer = buffer; } if (TestBit(kCanRebin) || (fXaxis.GetXmax() <= fXaxis.GetXmin())) { //find min, max of entries in buffer Double_t xmin = fBuffer[2]; Double_t xmax = xmin; for (Int_t i=1;i<nbentries;i++) { Double_t x = fBuffer[2*i+2]; if (x < xmin) xmin = x; if (x > xmax) xmax = x; } if (fXaxis.GetXmax() <= fXaxis.GetXmin()) { THLimitsFinder::GetLimitsFinder()->FindGoodLimits(this,xmin,xmax); } else { fBuffer = 0; Int_t keep = fBufferSize; fBufferSize = 0; if (xmin < fXaxis.GetXmin()) RebinAxis(xmin,&fXaxis); if (xmax >= fXaxis.GetXmax()) RebinAxis(xmax,&fXaxis); fBuffer = buffer; fBufferSize = keep; } } // call DoFillN which will not put entries in the buffer as FillN does // to avoid infinite loops // caused by FindBin->ReBinAxis->GetBinCOntent->BufferEmpy buffer = fBuffer; fBuffer = 0; DoFillN(nbentries,&buffer[2],&buffer[1],2); fBuffer = buffer; // if action == 1 - delete the buffer if (action > 0) { delete [] fBuffer; fBuffer = 0; fBufferSize = 0;} else { // if number of entries is consistent with buffer - set it negative to avoid // refilling the histogram every time BufferEmpty(0) is called // In case it is not consistent, by setting fBuffer[0]=0 is like resetting the buffer // (it will not be used anymore the next time BufferEmpty is called) if (nbentries == (Int_t)fEntries) fBuffer[0] = -nbentries; else fBuffer[0] = 0; } return nbentries; } //______________________________________________________________________________ Int_t TH1::BufferFill(Double_t x, Double_t w) { // accumulate arguments in buffer. When buffer is full, empty the buffer // fBuffer[0] = number of entries in buffer // fBuffer[1] = w of first entry // fBuffer[2] = x of first entry if (!fBuffer) return -2; Int_t nbentries = (Int_t)fBuffer[0]; if (nbentries < 0) { // reset nbentries to a positive value so next time BufferEmpty() is called // the histogram will be refilled nbentries = -nbentries; fBuffer[0] = nbentries; if (fEntries > 0) { // set fBuffer to zero to avoid calling BufferEmpty in Reset Double_t *buffer = fBuffer; fBuffer=0; Reset("ICES"); // do not reset list of functions fBuffer = buffer; } } if (2*nbentries+2 >= fBufferSize) { BufferEmpty(1); return Fill(x,w); } fBuffer[2*nbentries+1] = w; fBuffer[2*nbentries+2] = x; fBuffer[0] += 1; return -2; } bool TH1::CheckBinLimits(const TAxis* a1, const TAxis * a2) { const TArrayD * h1Array = a1->GetXbins(); const TArrayD * h2Array = a2->GetXbins(); Int_t fN = h1Array->fN; if ( fN != 0 ) { if ( h2Array->fN != fN ) { throw DifferentBinLimits(); return false; } else { for ( int i = 0; i < fN; ++i ) { if ( ! TMath::AreEqualRel( h1Array->GetAt(i), h2Array->GetAt(i), 1E-10 ) ) { throw DifferentBinLimits(); return false; } } } } return true; } bool TH1::CheckBinLabels(const TAxis* a1, const TAxis * a2) { // check that axis have same labels THashList *l1 = (const_cast<TAxis*>(a1))->GetLabels(); THashList *l2 = (const_cast<TAxis*>(a2))->GetLabels(); if (!l1 && !l2 ) return true; if (!l1 || !l2 ) { throw DifferentLabels(); return false; } // check now labels sizes are the same if (l1->GetSize() != l2->GetSize() ) { throw DifferentLabels(); return false; } for (int i = 1; i <= a1->GetNbins(); ++i) { TString label1 = a1->GetBinLabel(i); TString label2 = a2->GetBinLabel(i); if (label1 != label2) { throw DifferentLabels(); return false; } } return true; } bool TH1::CheckAxisLimits(const TAxis *a1, const TAxis *a2 ) { // Check that the axis limits of the histograms are the same // if a first and last bin is passed the axis is compared between the given range if ( ! TMath::AreEqualRel(a1->GetXmin(), a2->GetXmin(),1.E-12) || ! TMath::AreEqualRel(a1->GetXmax(), a2->GetXmax(),1.E-12) ) { throw DifferentAxisLimits(); return false; } return true; } bool TH1::CheckEqualAxes(const TAxis *a1, const TAxis *a2 ) { // Check that the axis are the same if (a1->GetNbins() != a2->GetNbins() ) { //throw DifferentNumberOfBins(); ::Info("CheckEqualAxes","Axes have different number of bins : nbin1 = %d nbin2 = %d",a1->GetNbins(),a2->GetNbins() ); return false; } try { CheckAxisLimits(a1,a2); } catch (DifferentAxisLimits&) { ::Info("CheckEqualAxes","Axes have different limits"); return false; } try { CheckBinLimits(a1,a2); } catch (DifferentBinLimits&) { ::Info("CheckEqualAxes","Axes have different bin limits"); return false; } // check labels try { CheckBinLabels(a1,a2); } catch (DifferentLabels&) { ::Info("CheckEqualAxes","Axes have different labels"); return false; } return true; } bool TH1::CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis * a2, Int_t firstBin2, Int_t lastBin2 ) { // Check that two sub axis are the same // the limits are defined by first bin and last bin // N.B. no check is done in this case for variable bins // By default is assumed that no bins are given for the second axis Int_t nbins1 = lastBin1-firstBin1 + 1; Double_t xmin1 = a1->GetBinLowEdge(firstBin1); Double_t xmax1 = a1->GetBinUpEdge(lastBin1); Int_t nbins2 = a2->GetNbins(); Double_t xmin2 = a2->GetXmin(); Double_t xmax2 = a2->GetXmax(); if (firstBin2 < lastBin2) { // in this case assume no bins are given for the second axis nbins2 = lastBin1-firstBin1 + 1; xmin2 = a1->GetBinLowEdge(firstBin1); xmax2 = a1->GetBinUpEdge(lastBin1); } if (nbins1 != nbins2 ) { ::Info("CheckConsistentSubAxes","Axes have different number of bins"); return false; } if ( ! TMath::AreEqualRel(xmin1,xmin2,1.E-12) || ! TMath::AreEqualRel(xmax1,xmax2,1.E-12) ) { ::Info("CheckConsistentSubAxes","Axes have different limits"); return false; } return true; } //___________________________________________________________________________ bool TH1::CheckConsistency(const TH1* h1, const TH1* h2) { // Check histogram compatibility if (h1 == h2) return true; if (h1->GetDimension() != h2->GetDimension() ) { throw DifferentDimension(); return false; } Int_t dim = h1->GetDimension(); // returns kTRUE if number of bins and bin limits are identical Int_t nbinsx = h1->GetNbinsX(); Int_t nbinsy = h1->GetNbinsY(); Int_t nbinsz = h1->GetNbinsZ(); // Check whether the histograms have the same number of bins. if (nbinsx != h2->GetNbinsX() || (dim > 1 && nbinsy != h2->GetNbinsY()) || (dim > 2 && nbinsz != h2->GetNbinsZ()) ) { throw DifferentNumberOfBins(); return false; } bool ret = true; // check axis limits ret &= CheckAxisLimits(h1->GetXaxis(), h2->GetXaxis()); if (dim > 1) ret &= CheckAxisLimits(h1->GetYaxis(), h2->GetYaxis()); if (dim > 2) ret &= CheckAxisLimits(h1->GetZaxis(), h2->GetZaxis()); // check bin limits ret &= CheckBinLimits(h1->GetXaxis(), h2->GetXaxis()); if (dim > 1) ret &= CheckBinLimits(h1->GetYaxis(), h2->GetYaxis()); if (dim > 2) ret &= CheckBinLimits(h1->GetZaxis(), h2->GetZaxis()); // check labels if histograms are both not empty if ( (h1->fTsumw != 0 || h1->GetEntries() != 0) && (h2->fTsumw != 0 || h2->GetEntries() != 0) ) { ret &= CheckBinLabels(h1->GetXaxis(), h2->GetXaxis()); if (dim > 1) ret &= CheckBinLabels(h1->GetYaxis(), h2->GetYaxis()); if (dim > 2) ret &= CheckBinLabels(h1->GetZaxis(), h2->GetZaxis()); } return ret; } //___________________________________________________________________________ Double_t TH1::Chi2Test(const TH1* h2, Option_t *option, Double_t *res) const { // Begin_Latex #chi^{2} End_Latex test for comparing weighted and unweighted histograms // // Function: Returns p-value. Other return values are specified by the 3rd parameter <br> // // Parameters: // // - h2: the second histogram // - option: // o "UU" = experiment experiment comparison (unweighted-unweighted) // o "UW" = experiment MC comparison (unweighted-weighted). Note that // the first histogram should be unweighted // o "WW" = MC MC comparison (weighted-weighted) // o "NORM" = to be used when one or both of the histograms is scaled // but the histogram originally was unweighted // o by default underflows and overlows are not included: // * "OF" = overflows included // * "UF" = underflows included // o "P" = print chi2, ndf, p_value, igood // o "CHI2" = returns chi2 instead of p-value // o "CHI2/NDF" = returns Begin_Latex #chi^{2}/ndf End_Latex // - res: not empty - computes normalized residuals and returns them in // this array // // The current implementation is based on the papers Begin_Latex #chi^{2} End_Latex test for comparison // of weighted and unweighted histograms" in Proceedings of PHYSTAT05 and // "Comparison weighted and unweighted histograms", arXiv:physics/0605123 // by N.Gagunashvili. This function has been implemented by Daniel Haertl in August 2006. // // Introduction: // // A frequently used technique in data analysis is the comparison of // histograms. First suggested by Pearson [1] the Begin_Latex #chi^{2} End_Latex test of // homogeneity is used widely for comparing usual (unweighted) histograms. // This paper describes the implementation modified Begin_Latex #chi^{2} End_Latex tests // for comparison of weighted and unweighted histograms and two weighted // histograms [2] as well as usual Pearson's Begin_Latex #chi^{2} End_Latex test for // comparison two usual (unweighted) histograms. // // Overview: // // Comparison of two histograms expect hypotheses that two histograms // represent identical distributions. To make a decision p-value should // be calculated. The hypotheses of identity is rejected if the p-value is // lower then some significance level. Traditionally significance levels // 0.1, 0.05 and 0.01 are used. The comparison procedure should include an // analysis of the residuals which is often helpful in identifying the // bins of histograms responsible for a significant overall Begin_Latex #chi^{2} End_Latex value. // Residuals are the difference between bin contents and expected bin // contents. Most convenient for analysis are the normalized residuals. If // hypotheses of identity are valid then normalized residuals are // approximately independent and identically distributed random variables // having N(0,1) distribution. Analysis of residuals expect test of above // mentioned properties of residuals. Notice that indirectly the analysis // of residuals increase the power of Begin_Latex #chi^{2} End_Latex test. // // Methods of comparison: // // Begin_Latex #chi^{2} End_Latex test for comparison two (unweighted) histograms: // Let us consider two histograms with the same binning and the number // of bins equal to r. Let us denote the number of events in the ith bin // in the first histogram as ni and as mi in the second one. The total // number of events in the first histogram is equal to: //Begin_Latex // N = #sum_{i=1}^{r} n_{i} //End_Latex // and //Begin_Latex // M = #sum_{i=1}^{r} m_{i} //End_Latex // in the second histogram. The hypothesis of identity (homogeneity) [3] // is that the two histograms represent random values with identical // distributions. It is equivalent that there exist r constants p1,...,pr, // such that //Begin_Latex // #sum_{i=1}^{r} p_{i}=1 //End_Latex // and the probability of belonging to the ith bin for some measured value // in both experiments is equal to pi. The number of events in the ith // bin is a random variable with a distribution approximated by a Poisson // probability distribution //Begin_Latex // #frac{e^{-Np_{i}}(Np_{i})^{n_{i}}}{n_{i}!} //End_Latex // for the first histogram and with distribution //Begin_Latex // #frac{e^{-Mp_{i}}(Mp_{i})^{m_{i}}}{m_{i}!} //End_Latex // for the second histogram. If the hypothesis of homogeneity is valid, // then the maximum likelihood estimator of pi, i=1,...,r, is //Begin_Latex // #hat{p}_{i}= #frac{n_{i}+m_{i}}{N+M} //End_Latex // and then //Begin_Latex // X^{2} = #sum_{i=1}^{r}#frac{(n_{i}-N#hat{p}_{i})^{2}}{N#hat{p}_{i}} + #sum_{i=1}^{r}#frac{(m_{i}-M#hat{p}_{i})^{2}}{M#hat{p}_{i}} = #frac{1}{MN} #sum_{i=1}^{r}#frac{(Mn_{i}-Nm_{i})^{2}}{n_{i}+m_{i}} //End_Latex // has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [3]. // The comparison procedure can include an analysis of the residuals which // is often helpful in identifying the bins of histograms responsible for // a significant overall Begin_Latex #chi^{2} End_Latexvalue. Most convenient for // analysis are the adjusted (normalized) residuals [4] //Begin_Latex // r_{i} = #frac{n_{i}-N#hat{p}_{i}}{#sqrt{N#hat{p}_{i}}#sqrt{(1-N/(N+M))(1-(n_{i}+m_{i})/(N+M))}} //End_Latex // If hypotheses of homogeneity are valid then residuals ri are // approximately independent and identically distributed random variables // having N(0,1) distribution. The application of the Begin_Latex #chi^{2} End_latex test has // restrictions related to the value of the expected frequencies Npi, // Mpi, i=1,...,r. A conservative rule formulated in [5] is that all the // expectations must be 1 or greater for both histograms. In practical // cases when expected frequencies are not known the estimated expected // frequencies Begin_Latex M#hat{p}_{i}, N#hat{p}_{i}, i=1,...,r End_Latex can be used. // // Unweighted and weighted histograms comparison: // // A simple modification of the ideas described above can be used for the // comparison of the usual (unweighted) and weighted histograms. Let us // denote the number of events in the ith bin in the unweighted // histogram as ni and the common weight of events in the ith bin of the // weighted histogram as wi. The total number of events in the // unweighted histogram is equal to //Begin_Latex // N = #sum_{i=1}^{r} n_{i} //End_Latex // and the total weight of events in the weighted histogram is equal to //Begin_Latex // W = #sum_{i=1}^{r} w_{i} //End_Latex // Let us formulate the hypothesis of identity of an unweighted histogram // to a weighted histogram so that there exist r constants p1,...,pr, such // that //Begin_Latex // #sum_{i=1}^{r} p_{i} = 1 //End_Latex // for the unweighted histogram. The weight wi is a random variable with a // distribution approximated by the normal probability distribution // Begin_Latex N(Wp_{i},#sigma_{i}^{2}) End_Latex where Begin_Latex #sigma_{i}^{2} End_Latex is the variance of the weight wi. // If we replace the variance Begin_Latex #sigma_{i}^{2} End_Latex // with estimate Begin_Latex s_{i}^{2} End_Latex (sum of squares of weights of // events in the ith bin) and the hypothesis of identity is valid, then the // maximum likelihood estimator of pi,i=1,...,r, is //Begin_Latex // #hat{p}_{i} = #frac{Ww_{i}-Ns_{i}^{2}+#sqrt{(Ww_{i}-Ns_{i}^{2})^{2}+4W^{2}s_{i}^{2}n_{i}}}{2W^{2}} //End_Latex // We may then use the test statistic //Begin_Latex // X^{2} = #sum_{i=1}^{r} #frac{(n_{i}-N#hat{p}_{i})^{2}}{N#hat{p}_{i}} + #sum_{i=1}^{r} #frac{(w_{i}-W#hat{p}_{i})^{2}}{s_{i}^{2}} //End_Latex // and it has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [2]. This test, as well // as the original one [3], has a restriction on the expected frequencies. The // expected frequencies recommended for the weighted histogram is more than 25. // The value of the minimal expected frequency can be decreased down to 10 for // the case when the weights of the events are close to constant. In the case // of a weighted histogram if the number of events is unknown, then we can // apply this recommendation for the equivalent number of events as //Begin_Latex // n_{i}^{equiv} = #frac{ w_{i}^{2} }{ s_{i}^{2} } //End_Latex // The minimal expected frequency for an unweighted histogram must be 1. Notice // that any usual (unweighted) histogram can be considered as a weighted // histogram with events that have constant weights equal to 1. // The variance Begin_Latex z_{i}^{2} End_Latex of the difference between the weight wi // and the estimated expectation value of the weight is approximately equal to: //Begin_Latex // z_{i}^{2} = Var(w_{i}-W#hat{p}_{i}) = N#hat{p}_{i}(1-N#hat{p}_{i})#left(#frac{Ws_{i}^{2}}{#sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}#right)^{2}+#frac{s_{i}^{2}}{4}#left(1+#frac{Ns_{i}^{2}-w_{i}W}{#sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}#right)^{2} //End_Latex // The residuals //Begin_Latex // r_{i} = #frac{w_{i}-W#hat{p}_{i}}{z_{i}} //End_Latex // have approximately a normal distribution with mean equal to 0 and standard // deviation equal to 1. // // Two weighted histograms comparison: // // Let us denote the common weight of events of the ith bin in the first // histogram as w1i and as w2i in the second one. The total weight of events // in the first histogram is equal to //Begin_Latex // W_{1} = #sum_{i=1}^{r} w_{1i} //End_Latex // and //Begin_Latex // W_{2} = #sum_{i=1}^{r} w_{2i} //End_Latex // in the second histogram. Let us formulate the hypothesis of identity of // weighted histograms so that there exist r constants p1,...,pr, such that //Begin_Latex // #sum_{i=1}^{r} p_{i} = 1 //End_Latex // and also expectation value of weight w1i equal to W1pi and expectation value // of weight w2i equal to W2pi. Weights in both the histograms are random // variables with distributions which can be approximated by a normal // probability distribution Begin_Latex N(W_{1}p_{i},#sigma_{1i}^{2}) End_Latex for the first histogram // and by a distribution Begin_Latex N(W_{2}p_{i},#sigma_{2i}^{2}) End_Latex for the second. // Here Begin_Latex #sigma_{1i}^{2} End_Latex and Begin_Latex #sigma_{2i}^{2} End_Latex are the variances // of w1i and w2i with estimators Begin_Latex s_{1i}^{2} End_Latex and Begin_Latex s_{2i}^{2} End_Latex respectively. // If the hypothesis of identity is valid, then the maximum likelihood and // Least Square Method estimator of pi,i=1,...,r, is //Begin_Latex // #hat{p}_{i} = #frac{w_{1i}W_{1}/s_{1i}^{2}+w_{2i}W_{2} /s_{2i}^{2}}{W_{1}^{2}/s_{1i}^{2}+W_{2}^{2}/s_{2i}^{2}} //End_Latex // We may then use the test statistic //Begin_Latex // X^{2} = #sum_{i=1}^{r} #frac{(w_{1i}-W_{1}#hat{p}_{i})^{2}}{s_{1i}^{2}} + #sum_{i=1}^{r} #frac{(w_{2i}-W_{2}#hat{p}_{i})^{2}}{s_{2i}^{2}} = #sum_{i=1}^{r} #frac{(W_{1}w_{2i}-W_{2}w_{1i})^{2}}{W_{1}^{2}s_{2i}^{2}+W_{2}^{2}s_{1i}^{2}} //End_Latex // and it has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [2]. // The normalized or studentised residuals [6] //Begin_Latex // r_{i} = #frac{w_{1i}-W_{1}#hat{p}_{i}}{s_{1i}#sqrt{1 - #frac{1}{(1+W_{2}^{2}s_{1i}^{2}/W_{1}^{2}s_{2i}^{2})}}} //End_Latex // have approximately a normal distribution with mean equal to 0 and standard // deviation 1. A recommended minimal expected frequency is equal to 10 for // the proposed test. // // Numerical examples: // // The method described herein is now illustrated with an example. // We take a distribution //Begin_Latex // #phi(x) = #frac{2}{(x-10)^{2}+1} + #frac{1}{(x-14)^{2}+1} (1) //End_Latex // defined on the interval [4,16]. Events distributed according to the formula // (1) are simulated to create the unweighted histogram. Uniformly distributed // events are simulated for the weighted histogram with weights calculated by // formula (1). Each histogram has the same number of bins: 20. Fig.1 shows // the result of comparison of the unweighted histogram with 200 events // (minimal expected frequency equal to one) and the weighted histogram with // 500 events (minimal expected frequency equal to 25) //Begin_Macro // ../../../tutorials/math/chi2test.C //End_Macro // Fig 1. An example of comparison of the unweighted histogram with 200 events // and the weighted histogram with 500 events: // a) unweighted histogram; // b) weighted histogram; // c) normalized residuals plot; // d) normal Q-Q plot of residuals. // // The value of the test statistic Begin_Latex #chi^{2} End_Latex is equal to // 21.09 with p-value equal to 0.33, therefore the hypothesis of identity of // the two histograms can be accepted for 0.05 significant level. The behavior // of the normalized residuals plot (see Fig. 1c) and the normal Q-Q plot // (see Fig. 1d) of residuals are regular and we cannot identify the outliers // or bins with a big influence on Begin_Latex #chi^{2} End_Latex. // // The second example presents the same two histograms but 17 events was added // to content of bin number 15 in unweighted histogram. Fig.2 shows the result // of comparison of the unweighted histogram with 217 events (minimal expected // frequency equal to one) and the weighted histogram with 500 events (minimal // expected frequency equal to 25) //Begin_Macro // ../../../tutorials/math/chi2test.C(17) //End_Macro // Fig 2. An example of comparison of the unweighted histogram with 217 events // and the weighted histogram with 500 events: // a) unweighted histogram; // b) weighted histogram; // c) normalized residuals plot; // d) normal Q-Q plot of residuals. // // The value of the test statistic Begin_Latex #chi^{2} End_Latex is equal to // 32.33 with p-value equal to 0.029, therefore the hypothesis of identity of // the two histograms is rejected for 0.05 significant level. The behavior of // the normalized residuals plot (see Fig. 2c) and the normal Q-Q plot (see // Fig. 2d) of residuals are not regular and we can identify the outlier or // bin with a big influence on Begin_Latex #chi^{2} End_Latex. // // References: // // [1] Pearson, K., 1904. On the Theory of Contingency and Its Relation to // Association and Normal Correlation. Drapers' Co. Memoirs, Biometric // Series No. 1, London. // [2] Gagunashvili, N., 2006. Begin_Latex #chi^{2} End_Latex test for comparison // of weighted and unweighted histograms. Statistical Problems in Particle // Physics, Astrophysics and Cosmology, Proceedings of PHYSTAT05, // Oxford, UK, 12-15 September 2005, Imperial College Press, London, 43-44. // Gagunashvili,N., Comparison of weighted and unweighted histograms, // arXiv:physics/0605123, 2006. // [3] Cramer, H., 1946. Mathematical methods of statistics. // Princeton University Press, Princeton. // [4] Haberman, S.J., 1973. The analysis of residuals in cross-classified tables. // Biometrics 29, 205-220. // [5] Lewontin, R.C. and Felsenstein, J., 1965. The robustness of homogeneity // test in 2xN tables. Biometrics 21, 19-33. // [6] Seber, G.A.F., Lee, A.J., 2003, Linear Regression Analysis. // John Wiley & Sons Inc., New York. Double_t chi2 = 0; Int_t ndf = 0, igood = 0; TString opt = option; opt.ToUpper(); Double_t prob = Chi2TestX(h2,chi2,ndf,igood,option,res); if(opt.Contains("P")) { printf("Chi2 = %f, Prob = %g, NDF = %d, igood = %d\n", chi2,prob,ndf,igood); } if(opt.Contains("CHI2/NDF")) { if (ndf == 0) return 0; return chi2/ndf; } if(opt.Contains("CHI2")) { return chi2; } return prob; } //___________________________________________________________________________ Double_t TH1::Chi2TestX(const TH1* h2, Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option, Double_t *res) const { // The computation routine of the Chisquare test. For the method description, // see Chi2Test() function. // Returns p-value // parameters: // - h2-second histogram // - option: // "UU" = experiment experiment comparison (unweighted-unweighted) // "UW" = experiment MC comparison (unweighted-weighted). Note that the first // histogram should be unweighted // "WW" = MC MC comparison (weighted-weighted) // // "NORM" = if one or both histograms is scaled // // "OF" = overflows included // "UF" = underflows included // by default underflows and overflows are not included // // - igood: // igood=0 - no problems // For unweighted unweighted comparison // igood=1'There is a bin in the 1st histogram with less than 1 event' // igood=2'There is a bin in the 2nd histogram with less than 1 event' // igood=3'when the conditions for igood=1 and igood=2 are satisfied' // For unweighted weighted comparison // igood=1'There is a bin in the 1st histogram with less then 1 event' // igood=2'There is a bin in the 2nd histogram with less then 10 effective number of events' // igood=3'when the conditions for igood=1 and igood=2 are satisfied' // For weighted weighted comparison // igood=1'There is a bin in the 1st histogram with less then 10 effective // number of events' // igood=2'There is a bin in the 2nd histogram with less then 10 effective // number of events' // igood=3'when the conditions for igood=1 and igood=2 are satisfied' // // - chi2 - chisquare of the test // - ndf - number of degrees of freedom (important, when both histograms have the same // empty bins) // - res - normalized residuals for further analysis Int_t i = 0, j=0, k = 0; Int_t i_start, i_end; Int_t j_start, j_end; Int_t k_start, k_end; Double_t bin1, bin2; Double_t err1,err2; Double_t sum1=0, sum2=0; Double_t sumw1=0, sumw2=0; chi2 = 0; ndf = 0; TString opt = option; opt.ToUpper(); TAxis *xaxis1 = this->GetXaxis(); TAxis *xaxis2 = h2->GetXaxis(); TAxis *yaxis1 = this->GetYaxis(); TAxis *yaxis2 = h2->GetYaxis(); TAxis *zaxis1 = this->GetZaxis(); TAxis *zaxis2 = h2->GetZaxis(); Int_t nbinx1 = xaxis1->GetNbins(); Int_t nbinx2 = xaxis2->GetNbins(); Int_t nbiny1 = yaxis1->GetNbins(); Int_t nbiny2 = yaxis2->GetNbins(); Int_t nbinz1 = zaxis1->GetNbins(); Int_t nbinz2 = zaxis2->GetNbins(); //check dimensions if (this->GetDimension() != h2->GetDimension() ){ Error("Chi2TestX","Histograms have different dimensions."); return 0; } //check number of channels if (nbinx1 != nbinx2) { Error("Chi2TestX","different number of x channels"); } if (nbiny1 != nbiny2) { Error("Chi2TestX","different number of y channels"); } if (nbinz1 != nbinz2) { Error("Chi2TestX","different number of z channels"); } //check for ranges i_start = j_start = k_start = 1; i_end = nbinx1; j_end = nbiny1; k_end = nbinz1; if (xaxis1->TestBit(TAxis::kAxisRange)) { i_start = xaxis1->GetFirst(); i_end = xaxis1->GetLast(); } if (yaxis1->TestBit(TAxis::kAxisRange)) { j_start = yaxis1->GetFirst(); j_end = yaxis1->GetLast(); } if (zaxis1->TestBit(TAxis::kAxisRange)) { k_start = zaxis1->GetFirst(); k_end = zaxis1->GetLast(); } if (opt.Contains("OF")) { if (this->GetDimension() == 3) k_end = ++nbinz1; if (this->GetDimension() >= 2) j_end = ++nbiny1; if (this->GetDimension() >= 1) i_end = ++nbinx1; } if (opt.Contains("UF")) { if (this->GetDimension() == 3) k_start = 0; if (this->GetDimension() >= 2) j_start = 0; if (this->GetDimension() >= 1) i_start = 0; } ndf = (i_end - i_start + 1)*(j_end - j_start + 1)*(k_end - k_start + 1) - 1; Bool_t comparisonUU = opt.Contains("UU"); Bool_t comparisonUW = opt.Contains("UW"); Bool_t comparisonWW = opt.Contains("WW"); Bool_t scaledHistogram = opt.Contains("NORM"); if (scaledHistogram && !comparisonUU) { Info("Chi2TestX","NORM option should be used together with UU option. It is ignored"); } // look at histo global bin content and effective entries Stat_t s[kNstat]; this->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights double sumBinContent1 = s[0]; double effEntries1 = (s[1] ? s[0]*s[0]/s[1] : 0.); h2->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights double sumBinContent2 = s[0]; double effEntries2 = (s[1] ? s[0]*s[0]/s[1] : 0.); if (!comparisonUU && !comparisonUW && !comparisonWW ) { // deduce automatically from type of histogram if (TMath::Abs(sumBinContent1 - effEntries1) < 1) { if ( TMath::Abs(sumBinContent2 - effEntries2) < 1) comparisonUU = true; else comparisonUW = true; } else comparisonWW = true; } // check unweighted histogram if (comparisonUW) { if (TMath::Abs(sumBinContent1 - effEntries1) >= 1) { Warning("Chi2TestX","First histogram is not unweighted and option UW has been requested"); } } if ( (!scaledHistogram && comparisonUU) ) { if ( ( TMath::Abs(sumBinContent1 - effEntries1) >= 1) || (TMath::Abs(sumBinContent2 - effEntries2) >= 1) ) { Warning("Chi2TestX","Both histograms are not unweighted and option UU has been requested"); } } //get number of events in histogram if (comparisonUU && scaledHistogram) { for (i=i_start; i<=i_end; i++) { for (j=j_start; j<=j_end; j++) { for (k=k_start; k<=k_end; k++) { bin1 = this->GetBinContent(i,j,k); bin2 = h2->GetBinContent(i,j,k); err1 = this->GetBinError(i,j,k); err2 = h2->GetBinError(i,j,k); if (err1 > 0 ) { bin1 *= bin1/(err1*err1); //avoid rounding errors bin1 = TMath::Floor(bin1+0.5); } else bin1 = 0; if (err2 > 0) { bin2 *= bin2/(err2*err2); //avoid rounding errors bin2 = TMath::Floor(bin2+0.5); } else bin2 = 0; // sum contents sum1 += bin1; sum2 += bin2; sumw1 += err1*err1; sumw2 += err2*err2; } } } if (sumw1 <= 0 || sumw2 <= 0) { Error("Chi2TestX","Cannot use option NORM when one histogram has all zero errors"); return 0; } } else { for (i=i_start; i<=i_end; i++) { for (j=j_start; j<=j_end; j++) { for (k=k_start; k<=k_end; k++) { sum1 += this->GetBinContent(i,j,k); sum2 += h2->GetBinContent(i,j,k); if ( comparisonWW ) { err1 = this->GetBinError(i,j,k); sumw1 += err1*err1; } if ( comparisonUW || comparisonWW ) { err2 = h2->GetBinError(i,j,k); sumw2 += err2*err2; } } } } } //checks that the histograms are not empty if (sum1 == 0 || sum2 == 0) { Error("Chi2TestX","one histogram is empty"); return 0; } if ( comparisonWW && ( sumw1 <= 0 && sumw2 <=0 ) ){ Error("Chi2TestX","Hist1 and Hist2 have both all zero errors\n"); return 0; } //THE TEST Int_t m=0, n=0; //Experiment - experiment comparison if (comparisonUU) { Double_t sum = sum1 + sum2; for (i=i_start; i<=i_end; i++) { for (j=j_start; j<=j_end; j++) { for (k=k_start; k<=k_end; k++) { bin1 = this->GetBinContent(i,j,k); bin2 = h2->GetBinContent(i,j,k); if (scaledHistogram) { // scale bin value to effective bin entries err1 = this->GetBinError(i,j,k); if (err1 > 0 ) { bin1 *= bin1/(err1*err1); //avoid rounding errors bin1 = TMath::Floor(bin1+0.5); } else bin1 = 0; err2 = h2->GetBinError(i,j,k); if (err2 > 0) { bin2 *= bin2/(err2*err2); //avoid rounding errors bin2 = TMath::Floor(bin2+0.5); } else bin2 = 0; } if ( (int(bin1) == 0) && (int(bin2) == 0) ) { --ndf; //no data means one degree of freedom less } else { Double_t binsum = bin1 + bin2; Double_t nexp1 = binsum*sum1/sum; //Double_t nexp2 = binsum*sum2/sum; // if(opt.Contains("P")) printf("bin %d p = %g\t",i,binsum/sum); if (res) res[i-i_start] = (bin1-nexp1)/TMath::Sqrt(nexp1); if (bin1 < 1) { m++; } if (bin2 < 1) { n++; } //Habermann correction for residuals Double_t correc = (1-sum1/sum)*(1-binsum/sum); if (res) { res[i-i_start] /= TMath::Sqrt(correc); } Double_t delta = sum2*bin1-sum1*bin2; chi2 += delta*delta/binsum; } } } } chi2 /= (sum1*sum2); // flag error only when of the two histogram is zero if (m) { igood += 1; Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n"); } if (n) { igood += 2; Info("Chi2TestX","There is a bin in h2 with less than 1 event.\n"); } Double_t prob = TMath::Prob(chi2,ndf); return prob; } //unweighted - weighted comparison // case of err2 = 0 and bin2 not zero is treated without problems // by excluding second chi2 sum // and can be considered as a comparison data-theory if ( comparisonUW ) { for (i=i_start; i<=i_end; i++) { for (j=j_start; j<=j_end; j++) { for (k=k_start; k<=k_end; k++) { Int_t x=0; bin1 = this->GetBinContent(i,j,k); bin2 = h2->GetBinContent(i,j,k); err2 = h2->GetBinError(i,j,k); err2 *= err2; // case both histogram have zero bin contents if ( (int(bin1) == 0) && (bin2*bin2 == 0) ) { --ndf; //no data means one degree of freedom less continue; } // case weighted histogram has zero bin content and error if (bin2*bin2 == 0 && err2 == 0) { if (sumw2 > 0) { // use as approximated error as 1 scaled by a scaling ratio // estimated from the total sum weight and sum weight squared err2 = sumw2/sum2; } else { // return error because infinite discrepancy here: // bin1 != 0 and bin2 =0 in a histogram with all errors zero Error("Chi2TestX","Hist2 has in bin %d,%d,%d zero content and all zero errors\n", i,j,k); chi2 = 0; return 0; } } if (bin1 < 1) m++; if (err2 > 0 && bin2*bin2/err2 < 10) n++; Double_t var1 = sum2*bin2 - sum1*err2; Double_t var2 = var1*var1 + 4*sum2*sum2*bin1*err2; // if bin1 is zero and bin2=1 and sum1=sum2 var1=0 && var2 ==0 // approximate by adding +1 to bin1 // LM (this need to be fixed for numerical errors) while (var1*var1+bin1 == 0 || var1+var2 == 0) { sum1++; bin1++; x++; var1 = sum2*bin2 - sum1*err2; var2 = var1*var1 + 4*sum2*sum2*bin1*err2; } var2 = TMath::Sqrt(var2); while (var1+var2 == 0) { sum1++; bin1++; x++; var1 = sum2*bin2 - sum1*err2; var2 = var1*var1 + 4*sum2*sum2*bin1*err2; while (var1*var1+bin1 == 0 || var1+var2 == 0) { sum1++; bin1++; x++; var1 = sum2*bin2 - sum1*err2; var2 = var1*var1 + 4*sum2*sum2*bin1*err2; } var2 = TMath::Sqrt(var2); } Double_t probb = (var1+var2)/(2*sum2*sum2); Double_t nexp1 = probb * sum1; Double_t nexp2 = probb * sum2; // if(opt.Contains("P")) printf("bin %d p = %g\t",i,probb); Double_t delta1 = bin1 - nexp1; Double_t delta2 = bin2 - nexp2; chi2 += delta1*delta1/nexp1; if (err2 > 0) { chi2 += delta2*delta2/err2; } if (res) { if (err2 > 0) { Double_t temp1 = sum2*err2/var2; Double_t temp2 = 1 + (sum1*err2 - sum2*bin2)/var2; temp2 = temp1*temp1*sum1*probb*(1-probb) + temp2*temp2*err2/4; // invert sign here res[i-i_start] = - delta2/TMath::Sqrt(temp2); } else res[i-i_start] = delta1/TMath::Sqrt(nexp1); } } } } if (m) { igood += 1; Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n"); } if (n) { igood += 2; Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n"); } Double_t prob = TMath::Prob(chi2,ndf); return prob; } // weighted - weighted comparison if (comparisonWW) { for (i=i_start; i<=i_end; i++) { for (j=j_start; j<=j_end; j++) { for (k=k_start; k<=k_end; k++) { bin1 = this->GetBinContent(i,j,k); bin2 = h2->GetBinContent(i,j,k); err1 = this->GetBinError(i,j,k); err2 = h2->GetBinError(i,j,k); err1 *= err1; err2 *= err2; // case both histogram have zero bin contents // (use square of bin1 to avoid numerical errors) if ( (bin1*bin1 == 0) && (bin2*bin2 == 0) ) { --ndf; //no data means one degree of freedom less continue; } if ( (err1 == 0) && (err2 == 0) ) { // cannot treat case of booth histogram have zero zero errors Error("Chi2TestX","h1 and h2 both have bin %d,%d,%d with all zero errors\n", i,j,k); chi2 = 0; return 0; } Double_t sigma = sum1*sum1*err2 + sum2*sum2*err1; Double_t delta = sum2*bin1 - sum1*bin2; chi2 += delta*delta/sigma; // if(opt.Contains("P")) printf("bin %d p = %g\t",i, (bin1*sum1/err1 + bin2*sum2/err2)/(sum1*sum1/err1 + sum2*sum2/err2)); if (res) { Double_t temp = bin1*sum1*err2 + bin2*sum2*err1; Double_t probb = temp/sigma; Double_t z = 0; if (err1 > err2 ) { Double_t d1 = (bin1 - sum1 * probb); Double_t s1 = err1* ( 1. - err2 * sum1 * sum1 / sigma ); z = d1/ TMath::Sqrt(s1); } else { Double_t d2 = (bin2 - sum2 * probb); Double_t s2 = err2* ( 1. - err1 * sum2 * sum2 / sigma ); z = -d2/ TMath::Sqrt(s2); } res[i-i_start] = z; } if (err1 > 0 && bin1*bin1/err1 < 10) m++; if (err2 > 0 && bin2*bin2/err2 < 10) n++; } } } if (m) { igood += 1; Info("Chi2TestX","There is a bin in h1 with less than 10 effective events.\n"); } if (n) { igood += 2; Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n"); } Double_t prob = TMath::Prob(chi2,ndf); return prob; } return 0; } //______________________________________________________________________________ Double_t TH1::Chisquare(TF1 * func, Option_t *option) const { // Compute and return the chisquare of this histogram with respect to a function // The chisquare is computed by weighting each histogram point by the bin error // By default the full range of the histogram is used. // Use option "R" for restricting the chisquare calculation to the given range of the function if (!func) { Error("Chisquare","Function pointer is Null - return -1"); return -1; } TString opt(option); opt.ToUpper(); bool useRange = opt.Contains("R"); return ROOT::Fit::Chisquare(*this, *func, useRange); } //______________________________________________________________________________ Double_t TH1::ComputeIntegral(Bool_t onlyPositive) { // Compute integral (cumulative sum of bins) // The result stored in fIntegral is used by the GetRandom functions. // This function is automatically called by GetRandom when the fIntegral // array does not exist or when the number of entries in the histogram // has changed since the previous call to GetRandom. // The resulting integral is normalized to 1 // If the routine is called with the onlyPositive flag set an error will // be produced in case of negative bin content and a NaN value returned Int_t bin, binx, biny, binz, ibin; // delete previously computed integral (if any) if (fIntegral) delete [] fIntegral; // - Allocate space to store the integral and compute integral Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); Int_t nxy = nbinsx*nbinsy; Int_t nbins = nxy*nbinsz; fIntegral = new Double_t[nbins+2]; ibin = 0; fIntegral[ibin] = 0; for (binz=1;binz<=nbinsz;binz++) { for (biny=1;biny<=nbinsy;biny++) { for (binx=1;binx<=nbinsx;binx++) { ibin++; bin = GetBin(binx, biny, binz); Double_t y = GetBinContent(bin); if (onlyPositive && y < 0) { Error("ComputeIntegral","Bin content is negative - return a NaN value"); fIntegral[nbins] = TMath::QuietNaN(); break; } fIntegral[ibin] = fIntegral[ibin-1] + y; } } } // - Normalize integral to 1 if (fIntegral[nbins] == 0 ) { Error("ComputeIntegral", "Integral = zero"); return 0; } for (bin=1;bin<=nbins;bin++) fIntegral[bin] /= fIntegral[nbins]; fIntegral[nbins+1] = fEntries; return fIntegral[nbins]; } //______________________________________________________________________________ Double_t *TH1::GetIntegral() { // Return a pointer to the array of bins integral. // if the pointer fIntegral is null, TH1::ComputeIntegral is called // The array dimension is the number of bins in the histograms // including underflow and overflow (fNCells) // the last value integral[fNCells] is set to the number of entries of // the histogram if (!fIntegral) ComputeIntegral(); return fIntegral; } //______________________________________________________________________________ TH1 *TH1::GetCumulative(Bool_t forward, const char* suffix) const { // Return a pointer to an histogram containing the cumulative The // cumulative can be computed both in the forward (default) or backward // direction; the name of the new histogram is constructed from // the name of this histogram with the suffix suffix appended. // // The cumulative distribution is formed by filling each bin of the // resulting histogram with the sum of that bin and all previous // (forward == kTRUE) or following (forward = kFALSE) bins. // // note: while cumulative distributions make sense in one dimension, you // may not be getting what you expect in more than 1D because the concept // of a cumulative distribution is much trickier to define; make sure you // understand the order of summation before you use this method with // histograms of dimension >= 2. const Int_t nbinsx = GetNbinsX(); const Int_t nbinsy = GetNbinsY(); const Int_t nbinsz = GetNbinsZ(); TH1* hintegrated = (TH1*) Clone(fName + suffix); hintegrated->Reset(); if (forward) { // Forward computation Double_t sum = 0.; for (Int_t binz = 1; binz <= nbinsz; ++binz) { for (Int_t biny = 1; biny <= nbinsy; ++biny) { for (Int_t binx = 1; binx <= nbinsx; ++binx) { const Int_t bin = hintegrated->GetBin(binx, biny, binz); sum += GetBinContent(bin); hintegrated->SetBinContent(bin, sum); } } } } else { // Backward computation Double_t sum = 0.; for (Int_t binz = nbinsz; binz >= 1; --binz) { for (Int_t biny = nbinsy; biny >= 1; --biny) { for (Int_t binx = nbinsx; binx >= 1; --binx) { const Int_t bin = hintegrated->GetBin(binx, biny, binz); sum += GetBinContent(bin); hintegrated->SetBinContent(bin, sum); } } } } return hintegrated; } //______________________________________________________________________________ void TH1::Copy(TObject &obj) const { // -*-*-*-*-*Copy this histogram structure to newth1*-*-*-*-*-*-*-*-*-*-*-* // ======================================= // // Note that this function does not copy the list of associated functions. // Use TObject::Clone to make a full copy of an histogram. if (((TH1&)obj).fDirectory) { // We are likely to change the hash value of this object // with TNamed::Copy, to keep things correct, we need to // clean up its existing entries. ((TH1&)obj).fDirectory->Remove(&obj); ((TH1&)obj).fDirectory = 0; } TNamed::Copy(obj); ((TH1&)obj).fDimension = fDimension; ((TH1&)obj).fNormFactor= fNormFactor; ((TH1&)obj).fNcells = fNcells; ((TH1&)obj).fBarOffset = fBarOffset; ((TH1&)obj).fBarWidth = fBarWidth; ((TH1&)obj).fOption = fOption; ((TH1&)obj).fBufferSize= fBufferSize; // copy the Buffer // delete first a previously existing buffer if (((TH1&)obj).fBuffer != 0) { delete [] ((TH1&)obj).fBuffer; ((TH1&)obj).fBuffer = 0; } if (fBuffer) { Double_t *buf = new Double_t[fBufferSize]; for (Int_t i=0;i<fBufferSize;i++) buf[i] = fBuffer[i]; // obj.fBuffer has been deleted before ((TH1&)obj).fBuffer = buf; } TArray* a = dynamic_cast<TArray*>(&obj); if (a) a->Set(fNcells); Int_t canRebin = ((TH1&)obj).TestBit(kCanRebin); ((TH1&)obj).ResetBit(kCanRebin); //we want to avoid the call to LabelsInflate // we need to set fBuffer to zero to avoid calling BufferEmpty in GetBinContent Double_t * buffer = 0; if (fBuffer) { buffer = fBuffer; ((TH1*)this)->fBuffer = 0; } for (Int_t i=0;i<fNcells;i++) ((TH1&)obj).SetBinContent(i,this->GetBinContent(i)); // restore rebin bit and buffer pointer if (canRebin) ((TH1&)obj).SetBit(kCanRebin); if (buffer) ((TH1*)this)->fBuffer = buffer; ((TH1&)obj).fEntries = fEntries; // which will call BufferEmpty(0) and set fBuffer[0] to a Maybe one should call // assignment operator on the TArrayD ((TH1&)obj).fTsumw = fTsumw; ((TH1&)obj).fTsumw2 = fTsumw2; ((TH1&)obj).fTsumwx = fTsumwx; ((TH1&)obj).fTsumwx2 = fTsumwx2; ((TH1&)obj).fMaximum = fMaximum; ((TH1&)obj).fMinimum = fMinimum; TAttLine::Copy(((TH1&)obj)); TAttFill::Copy(((TH1&)obj)); TAttMarker::Copy(((TH1&)obj)); fXaxis.Copy(((TH1&)obj).fXaxis); fYaxis.Copy(((TH1&)obj).fYaxis); fZaxis.Copy(((TH1&)obj).fZaxis); ((TH1&)obj).fXaxis.SetParent(&obj); ((TH1&)obj).fYaxis.SetParent(&obj); ((TH1&)obj).fZaxis.SetParent(&obj); fContour.Copy(((TH1&)obj).fContour); fSumw2.Copy(((TH1&)obj).fSumw2); // fFunctions->Copy(((TH1&)obj).fFunctions); if (fgAddDirectory && gDirectory) { gDirectory->Append(&obj); ((TH1&)obj).fDirectory = gDirectory; } } //______________________________________________________________________________ void TH1::DirectoryAutoAdd(TDirectory *dir) { // Perform the automatic addition of the histogram to the given directory // // Note this function is called in place when the semantic requires // this object to be added to a directory (I.e. when being read from // a TKey or being Cloned) // Bool_t addStatus = TH1::AddDirectoryStatus(); if (addStatus) { SetDirectory(dir); if (dir) { ResetBit(kCanDelete); } } } //______________________________________________________________________________ Int_t TH1::DistancetoPrimitive(Int_t px, Int_t py) { // -*-*-*-*-*-*-*-*-*Compute distance from point px,py to a line*-*-*-*-*-* // =========================================== // Compute the closest distance of approach from point px,py to elements // of an histogram. // The distance is computed in pixels units. // // Algorithm: // Currently, this simple model computes the distance from the mouse // to the histogram contour only. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (!fPainter) return 9999; return fPainter->DistancetoPrimitive(px,py); } //______________________________________________________________________________ Bool_t TH1::Divide(TF1 *f1, Double_t c1) { // Performs the operation: this = this/(c1*f1) // if errors are defined (see TH1::Sumw2), errors are also recalculated. // // Only bins inside the function range are recomputed. // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Divide // // The function return kFALSE if the divide operation failed if (!f1) { Error("Add","Attempt to divide by a non-existing function"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; SetMinimum(); SetMaximum(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t cu,w; Double_t xx[3]; Double_t *params = 0; f1->InitArgs(xx,params); for (binz=0;binz<=nbinsz+1;binz++) { xx[2] = fZaxis.GetBinCenter(binz); for (biny=0;biny<=nbinsy+1;biny++) { xx[1] = fYaxis.GetBinCenter(biny); for (binx=0;binx<=nbinsx+1;binx++) { xx[0] = fXaxis.GetBinCenter(binx); if (!f1->IsInside(xx)) continue; TF1::RejectPoint(kFALSE); bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); Double_t error1 = GetBinError(bin); cu = c1*f1->EvalPar(xx); if (TF1::RejectedPoint()) continue; if (cu) w = GetBinContent(bin)/cu; else w = 0; SetBinContent(bin,w); if (fSumw2.fN) { if (cu != 0) fSumw2.fArray[bin] = error1*error1/(cu*cu); else fSumw2.fArray[bin] = 0; } } } } ResetStats(); return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Divide(const TH1 *h1) { // -*-*-*-*-*-*-*-*-*Divide this histogram by h1*-*-*-*-*-*-*-*-*-*-*-*-* // =========================== // // this = this/h1 // if errors are defined (see TH1::Sumw2), errors are also recalculated. // Note that if h1 has Sumw2 set, Sumw2 is automatically called for this // if not already set. // The resulting errors are calculated assuming uncorrelated histograms. // See the other TH1::Divide that gives the possibility to optionally // compute binomial errors. // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Scale // // The function return kFALSE if the divide operation failed if (!h1) { Error("Divide","Attempt to divide by a non-existing histogram"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); try { CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Divide","Attempt to divide histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Divide","Attempt to divide histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Divide","Attempt to divide histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Divide","Attempt to divide histograms with different labels"); } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 has Sumw2 set if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t c0,c1,w; for (binz=0;binz<=nbinsz+1;binz++) { for (biny=0;biny<=nbinsy+1;biny++) { for (binx=0;binx<=nbinsx+1;binx++) { bin = GetBin(binx,biny,binz); c0 = GetBinContent(bin); c1 = h1->GetBinContent(bin); if (c1) w = c0/c1; else w = 0; SetBinContent(bin,w); if (fSumw2.fN) { Double_t e0 = GetBinError(bin); Double_t e1 = h1->GetBinError(bin); Double_t c12= c1*c1; if (!c1) { fSumw2.fArray[bin] = 0; continue;} fSumw2.fArray[bin] = (e0*e0*c1*c1 + e1*e1*c0*c0)/(c12*c12); } } } } ResetStats(); return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Divide(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t *option) { // -*-*-*Replace contents of this histogram by the division of h1 by h2*-*-* // ============================================================== // // this = c1*h1/(c2*h2) // // if errors are defined (see TH1::Sumw2), errors are also recalculated // Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this // if not already set. // The resulting errors are calculated assuming uncorrelated histograms. // However, if option ="B" is specified, Binomial errors are computed. // In this case c1 and c2 do not make real sense and they are ignored. // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Divide // // Please note also that in the binomial case errors are calculated using standard // binomial statistics, which means when b1 = b2, the error is zero. // If you prefer to have efficiency errors not going to zero when the efficiency is 1, you must // use the function TGraphAsymmErrors::BayesDivide, which will return an asymmetric and non-zero lower // error for the case b1=b2. // // The function return kFALSE if the divide operation failed TString opt = option; opt.ToLower(); Bool_t binomial = kFALSE; if (opt.Contains("b")) binomial = kTRUE; if (!h1 || !h2) { Error("Divide","Attempt to divide by a non-existing histogram"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); try { CheckConsistency(h1,h2); CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Divide","Attempt to divide histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Divide","Attempt to divide histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Divide","Attempt to divide histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Divide","Attempt to divide histograms with different labels"); } if (!c2) { Error("Divide","Coefficient of dividing histogram cannot be zero"); return kFALSE; } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 or h2 have Sumw2 set if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2(); SetMinimum(); SetMaximum(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t b1,b2,w,d1,d2; d1 = c1*c1; d2 = c2*c2; for (binz=0;binz<=nbinsz+1;binz++) { for (biny=0;biny<=nbinsy+1;biny++) { for (binx=0;binx<=nbinsx+1;binx++) { bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); b1 = h1->GetBinContent(bin); b2 = h2->GetBinContent(bin); if (b2) w = c1*b1/(c2*b2); else w = 0; SetBinContent(bin,w); if (fSumw2.fN) { Double_t e1 = h1->GetBinError(bin); Double_t e2 = h2->GetBinError(bin); Double_t b22= b2*b2*d2; if (!b2) { fSumw2.fArray[bin] = 0; continue;} if (binomial) { if (b1 != b2) { // in the case of binomial statistics c1 and c2 must be 1 otherwise it does not make sense w = b1/b2; // c1 and c2 are ignored //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));//this is the formula in Hbook/Hoper1 //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/b2); // old formula from G. Flucke // formula which works also for weighted histogram (see http://root.cern.ch/phpBB2/viewtopic.php?t=3753 ) fSumw2.fArray[bin] = TMath::Abs( ( (1.-2.*w)*e1*e1 + w*w*e2*e2 )/(b2*b2) ); } else { //in case b1=b2 error is zero //use TGraphAsymmErrors::BayesDivide for getting the asymmetric error not equal to zero fSumw2.fArray[bin] = 0; } } else { fSumw2.fArray[bin] = d1*d2*(e1*e1*b2*b2 + e2*e2*b1*b1)/(b22*b22); } } } } } ResetStats(); if (binomial) // in case of binomial division use denominator for number of entries SetEntries ( h2->GetEntries() ); return kTRUE; } //______________________________________________________________________________ void TH1::Draw(Option_t *option) { // Draw this histogram with options. // // Histograms are drawn via the THistPainter class. Each histogram has // a pointer to its own painter (to be usable in a multithreaded program). // The same histogram can be drawn with different options in different pads. // When an histogram drawn in a pad is deleted, the histogram is // automatically removed from the pad or pads where it was drawn. // If an histogram is drawn in a pad, then filled again, the new status // of the histogram will be automatically shown in the pad next time // the pad is updated. One does not need to redraw the histogram. // To draw the current version of an histogram in a pad, one can use // h->DrawCopy(); // This makes a clone of the histogram. Once the clone is drawn, the original // histogram may be modified or deleted without affecting the aspect of the // clone. // By default, TH1::Draw clears the current pad. // // One can use TH1::SetMaximum and TH1::SetMinimum to force a particular // value for the maximum or the minimum scale on the plot. // // TH1::UseCurrentStyle can be used to change all histogram graphics // attributes to correspond to the current selected style. // This function must be called for each histogram. // In case one reads and draws many histograms from a file, one can force // the histograms to inherit automatically the current graphics style // by calling before gROOT->ForceStyle(); // // See the THistPainter class for a description of all the drawing options. TString opt1 = option; opt1.ToLower(); TString opt2 = option; Int_t index = opt1.Index("same"); // Check if the string "same" is part of a TCutg name. if (index>=0) { Int_t indb = opt1.Index("["); if (indb>=0) { Int_t indk = opt1.Index("]"); if (index>indb && index<indk) index = -1; } } // If there is no pad or an empty pad the the "same" is ignored. if (gPad) { if (!gPad->IsEditable()) gROOT->MakeDefCanvas(); if (index>=0) { if (gPad->GetX1() == 0 && gPad->GetX2() == 1 && gPad->GetY1() == 0 && gPad->GetY2() == 1 && gPad->GetListOfPrimitives()->GetSize()==0) opt2.Remove(index,4); } else { //the following statement is necessary in case one attempts to draw //a temporary histogram already in the current pad if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this); gPad->Clear(); } } else { if (index>=0) opt2.Remove(index,4); } AppendPad(opt2.Data()); } //______________________________________________________________________________ TH1 *TH1::DrawCopy(Option_t *) const { // -*-*-*-*-*Copy this histogram and Draw in the current pad*-*-*-*-*-*-*-* // =============================================== // // Once the histogram is drawn into the pad, any further modification // using graphics input will be made on the copy of the histogram, // and not to the original object. // // See Draw for the list of options // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* AbstractMethod("DrawCopy"); return 0; } //______________________________________________________________________________ TH1 *TH1::DrawNormalized(Option_t *option, Double_t norm) const { // Draw a normalized copy of this histogram. // // A clone of this histogram is normalized to norm and drawn with option. // A pointer to the normalized histogram is returned. // The contents of the histogram copy are scaled such that the new // sum of weights (excluding under and overflow) is equal to norm. // Note that the returned normalized histogram is not added to the list // of histograms in the current directory in memory. // It is the user's responsability to delete this histogram. // The kCanDelete bit is set for the returned object. If a pad containing // this copy is cleared, the histogram will be automatically deleted // // See Draw for the list of options // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Double_t sum = GetSumOfWeights(); if (sum == 0) { Error("DrawNormalized","Sum of weights is null. Cannot normalize histogram: %s",GetName()); return 0; } Bool_t addStatus = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); TH1 *h = (TH1*)Clone(); h->SetBit(kCanDelete); // in case of drawing with error options - scale correctly the error TString opt(option); opt.ToUpper(); if (fSumw2.fN == 0) { h->Sumw2(); // do not use in this case the "Error option " for drawing which is enabled by default since the normalized histogram has now errors if (opt.IsNull() || opt == "SAME") opt += "HIST"; } h->Scale(norm/sum); if (TMath::Abs(fMaximum+1111) > 1e-3) h->SetMaximum(fMaximum*norm/sum); if (TMath::Abs(fMinimum+1111) > 1e-3) h->SetMinimum(fMinimum*norm/sum); h->Draw(opt); TH1::AddDirectory(addStatus); return h; } //______________________________________________________________________________ void TH1::DrawPanel() { // -*-*-*-*-*Display a panel with all histogram drawing options*-*-*-*-*-* // ================================================== // // See class TDrawPanelHist for example if (!fPainter) {Draw(); if (gPad) gPad->Update();} if (fPainter) fPainter->DrawPanel(); } //______________________________________________________________________________ void TH1::Eval(TF1 *f1, Option_t *option) { // -*-*-*Evaluate function f1 at the center of bins of this histogram-*-*-*-* // ============================================================ // // If option "R" is specified, the function is evaluated only // for the bins included in the function range. // If option "A" is specified, the value of the function is added to the // existing bin contents // If option "S" is specified, the value of the function is used to // generate a value, distributed according to the Poisson // distribution, with f1 as the mean. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Double_t x[3]; Int_t range,stat,add,bin,binx,biny,binz,nbinsx, nbinsy, nbinsz; if (!f1) return; Double_t fu; Double_t e=0; TString opt = option; opt.ToLower(); if (opt.Contains("a")) add = 1; else add = 0; if (opt.Contains("s")) stat = 1; else stat = 0; if (opt.Contains("r")) range = 1; else range = 0; // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); nbinsx = fXaxis.GetNbins(); nbinsy = fYaxis.GetNbins(); nbinsz = fZaxis.GetNbins(); if (!add) Reset(); for (binz=1;binz<=nbinsz;binz++) { x[2] = fZaxis.GetBinCenter(binz); for (biny=1;biny<=nbinsy;biny++) { x[1] = fYaxis.GetBinCenter(biny); for (binx=1;binx<=nbinsx;binx++) { bin = GetBin(binx,biny,binz); x[0] = fXaxis.GetBinCenter(binx); if (range && !f1->IsInside(x)) continue; fu = f1->Eval(x[0],x[1],x[2]); if (stat) fu = gRandom->PoissonD(fu); if (fSumw2.fN) e = fSumw2.fArray[bin]; AddBinContent(bin,fu); if (fSumw2.fN) fSumw2.fArray[bin] = e+ TMath::Abs(fu); } } } } //______________________________________________________________________________ void TH1::ExecuteEvent(Int_t event, Int_t px, Int_t py) { // -*-*-*-*-*-*-*-*-*Execute action corresponding to one event*-*-*-* // ========================================= // This member function is called when a histogram is clicked with the locator // // If Left button clicked on the bin top value, then the content of this bin // is modified according to the new position of the mouse when it is released. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (fPainter) fPainter->ExecuteEvent(event, px, py); } //______________________________________________________________________________ TH1* TH1::FFT(TH1* h_output, Option_t *option) { // This function allows to do discrete Fourier transforms of TH1 and TH2. // Available transform types and flags are described below. // // To extract more information about the transform, use the function // TVirtualFFT::GetCurrentTransform() to get a pointer to the current // transform object. // // Parameters: // 1st - histogram for the output. If a null pointer is passed, a new histogram is created // and returned, otherwise, the provided histogram is used and should be big enough // // Options: option parameters consists of 3 parts: // - option on what to return // "RE" - returns a histogram of the real part of the output // "IM" - returns a histogram of the imaginary part of the output // "MAG"- returns a histogram of the magnitude of the output // "PH" - returns a histogram of the phase of the output // // - option of transform type // "R2C" - real to complex transforms - default // "R2HC" - real to halfcomplex (special format of storing output data, // results the same as for R2C) // "DHT" - discrete Hartley transform // real to real transforms (sine and cosine): // "R2R_0", "R2R_1", "R2R_2", "R2R_3" - discrete cosine transforms of types I-IV // "R2R_4", "R2R_5", "R2R_6", "R2R_7" - discrete sine transforms of types I-IV // To specify the type of each dimension of a 2-dimensional real to real // transform, use options of form "R2R_XX", for example, "R2R_02" for a transform, // which is of type "R2R_0" in 1st dimension and "R2R_2" in the 2nd. // // - option of transform flag // "ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal // performance // "M" (from "measure") - some time spend in finding the optimal way to do the transform // "P" (from "patient") - more time spend in finding the optimal way to do the transform // "EX" (from "exhaustive") - the most optimal way is found // This option should be chosen depending on how many transforms of the same size and // type are going to be done. Planning is only done once, for the first transform of this // size and type. Default is "ES". // Examples of valid options: "Mag R2C M" "Re R2R_11" "Im R2C ES" "PH R2HC EX" Int_t ndim[3]; ndim[0] = this->GetNbinsX(); ndim[1] = this->GetNbinsY(); ndim[2] = this->GetNbinsZ(); TVirtualFFT *fft; TString opt = option; opt.ToUpper(); if (!opt.Contains("2R")){ if (!opt.Contains("2C") && !opt.Contains("2HC") && !opt.Contains("DHT")) { //no type specified, "R2C" by default opt.Append("R2C"); } fft = TVirtualFFT::FFT(this->GetDimension(), ndim, opt.Data()); } else { //find the kind of transform Int_t ind = opt.Index("R2R", 3); Int_t *kind = new Int_t[2]; char t; t = opt[ind+4]; kind[0] = atoi(&t); if (h_output->GetDimension()>1) { t = opt[ind+5]; kind[1] = atoi(&t); } fft = TVirtualFFT::SineCosine(this->GetDimension(), ndim, kind, option); delete [] kind; } if (!fft) return 0; Int_t in=0; for (Int_t binx = 1; binx<=ndim[0]; binx++) { for (Int_t biny=1; biny<=ndim[1]; biny++) { for (Int_t binz=1; binz<=ndim[2]; binz++) { fft->SetPoint(in, this->GetBinContent(binx, biny, binz)); in++; } } } fft->Transform(); h_output = TransformHisto(fft, h_output, option); return h_output; } //______________________________________________________________________________ Int_t TH1::Fill(Double_t x) { // -*-*-*-*-*-*-*-*Increment bin with abscissa X by 1*-*-*-*-*-*-*-*-*-*-* // ================================== // // if x is less than the low-edge of the first bin, the Underflow bin is incremented // if x is greater than the upper edge of last bin, the Overflow bin is incremented // // If the storage of the sum of squares of weights has been triggered, // via the function Sumw2, then the sum of the squares of weights is incremented // by 1 in the bin corresponding to x. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (fBuffer) return BufferFill(x,1); Int_t bin; fEntries++; bin =fXaxis.FindBin(x); if (bin <0) return -1; AddBinContent(bin); if (fSumw2.fN) ++fSumw2.fArray[bin]; if (bin == 0 || bin > fXaxis.GetNbins()) { if (!fgStatOverflows) return -1; } ++fTsumw; ++fTsumw2; fTsumwx += x; fTsumwx2 += x*x; return bin; } //______________________________________________________________________________ Int_t TH1::Fill(Double_t x, Double_t w) { // -*-*-*-*-*-*Increment bin with abscissa X with a weight w*-*-*-*-*-*-*-* // ============================================= // // if x is less than the low-edge of the first bin, the Underflow bin is incremented // if x is greater than the upper edge of last bin, the Overflow bin is incremented // // If the storage of the sum of squares of weights has been triggered, // via the function Sumw2, then the sum of the squares of weights is incremented // by w^2 in the bin corresponding to x. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (fBuffer) return BufferFill(x,w); Int_t bin; fEntries++; bin =fXaxis.FindBin(x); if (bin <0) return -1; AddBinContent(bin, w); if (fSumw2.fN) fSumw2.fArray[bin] += w*w; if (bin == 0 || bin > fXaxis.GetNbins()) { if (!fgStatOverflows) return -1; } //Double_t z= (w > 0 ? w : -w); Double_t z= w; fTsumw += z; fTsumw2 += z*z; fTsumwx += z*x; fTsumwx2 += z*x*x; return bin; } //______________________________________________________________________________ Int_t TH1::Fill(const char *namex, Double_t w) { // Increment bin with namex with a weight w // // if x is less than the low-edge of the first bin, the Underflow bin is incremented // if x is greater than the upper edge of last bin, the Overflow bin is incremented // // If the storage of the sum of squares of weights has been triggered, // via the function Sumw2, then the sum of the squares of weights is incremented // by w^2 in the bin corresponding to x. // Int_t bin; fEntries++; bin =fXaxis.FindBin(namex); if (bin <0) return -1; AddBinContent(bin, w); if (fSumw2.fN) fSumw2.fArray[bin] += w*w; if (bin == 0 || bin > fXaxis.GetNbins()) return -1; //Double_t z= (w > 0 ? w : -w); Double_t z= w; fTsumw += z; fTsumw2 += z*z; // this make sense if the histogram is not expanding (kCanRebin is not set) if (!TestBit(TH1::kCanRebin)) { Double_t x = fXaxis.GetBinCenter(bin); fTsumwx += z*x; fTsumwx2 += z*x*x; } return bin; } //______________________________________________________________________________ void TH1::FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride) { // Fill this histogram with an array x and weights w. // // ntimes: number of entries in arrays x and w (array size must be ntimes*stride) // x: array of values to be histogrammed // w: array of weighs // stride: step size through arrays x and w // // If the weight is not equal to 1, the storage of the sum of squares of // weights is automatically triggered and the sum of the squares of weights is incremented // by w^2 in the bin corresponding to x. // if w is NULL each entry is assumed a weight=1 //If a buffer is activated, fill buffer if (fBuffer) { ntimes *= stride; Int_t i = 0; for (i=0;i<ntimes;i+=stride) { if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty if (w) BufferFill(x[i],w[i]); else BufferFill(x[i], 1.); } // fill the remaining entries if the buffer has been deleted if (i < ntimes && fBuffer==0) DoFillN((ntimes-i)/stride,&x[i],&w[i],stride); return; } // call internal method DoFillN(ntimes, x, w, stride); } //______________________________________________________________________________ void TH1::DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride) { // internal method to fill histogram content from a vector // called directly by TH1::BufferEmpty Int_t bin,i; fEntries += ntimes; Double_t ww = 1; Int_t nbins = fXaxis.GetNbins(); ntimes *= stride; for (i=0;i<ntimes;i+=stride) { bin =fXaxis.FindBin(x[i]); if (bin <0) continue; if (w) ww = w[i]; AddBinContent(bin, ww); if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww; if (bin == 0 || bin > nbins) { if (!fgStatOverflows) continue; } //Double_t z= (ww > 0 ? ww : -ww); Double_t z= ww; fTsumw += z; fTsumw2 += z*z; fTsumwx += z*x[i]; fTsumwx2 += z*x[i]*x[i]; } } //______________________________________________________________________________ void TH1::FillRandom(const char *fname, Int_t ntimes) { // -*-*-*-*-*Fill histogram following distribution in function fname*-*-*-* // ======================================================= // // The distribution contained in the function fname (TF1) is integrated // over the channel contents for the bin range of this histogram. // It is normalized to 1. // Getting one random number implies: // - Generating a random number between 0 and 1 (say r1) // - Look in which bin in the normalized integral r1 corresponds to // - Fill histogram channel // ntimes random numbers are generated // // One can also call TF1::GetRandom to get a random variate from a function. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-* Int_t bin, binx, ibin, loop; Double_t r1, x; // - Search for fname in the list of ROOT defined functions TF1 *f1 = (TF1*)gROOT->GetFunction(fname); if (!f1) { Error("FillRandom", "Unknown function: %s",fname); return; } // - Allocate temporary space to store the integral and compute integral Int_t first = fXaxis.GetFirst(); Int_t last = fXaxis.GetLast(); Int_t nbinsx = last-first+1; Double_t *integral = new Double_t[nbinsx+1]; integral[0] = 0; for (binx=1;binx<=nbinsx;binx++) { Double_t fint = f1->Integral(fXaxis.GetBinLowEdge(binx+first-1),fXaxis.GetBinUpEdge(binx+first-1)); integral[binx] = integral[binx-1] + fint; } // - Normalize integral to 1 if (integral[nbinsx] == 0 ) { delete [] integral; Error("FillRandom", "Integral = zero"); return; } for (bin=1;bin<=nbinsx;bin++) integral[bin] /= integral[nbinsx]; // --------------Start main loop ntimes for (loop=0;loop<ntimes;loop++) { r1 = gRandom->Rndm(loop); ibin = TMath::BinarySearch(nbinsx,&integral[0],r1); //binx = 1 + ibin; //x = fXaxis.GetBinCenter(binx); //this is not OK when SetBuffer is used x = fXaxis.GetBinLowEdge(ibin+first) +fXaxis.GetBinWidth(ibin+first)*(r1-integral[ibin])/(integral[ibin+1] - integral[ibin]); Fill(x, 1.); } delete [] integral; } //______________________________________________________________________________ void TH1::FillRandom(TH1 *h, Int_t ntimes) { // -*-*-*-*-*Fill histogram following distribution in histogram h*-*-*-* // ==================================================== // // The distribution contained in the histogram h (TH1) is integrated // over the channel contents for the bin range of this histogram. // It is normalized to 1. // Getting one random number implies: // - Generating a random number between 0 and 1 (say r1) // - Look in which bin in the normalized integral r1 corresponds to // - Fill histogram channel // ntimes random numbers are generated // // SPECIAL CASE when the target histogram has the same binning as the source. // in this case we simply use a poisson distribution where // the mean value per bin = bincontent/integral. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**-*-*-*-*-*-*-* if (!h) { Error("FillRandom", "Null histogram"); return; } if (fDimension != h->GetDimension()) { Error("FillRandom", "Histograms with different dimensions"); return; } //in case the target histogram has the same binning and ntimes much greater //than the number of bins we can use a fast method Int_t first = fXaxis.GetFirst(); Int_t last = fXaxis.GetLast(); Int_t nbins = last-first+1; if (ntimes > 10*nbins) { try { CheckConsistency(this,h); Double_t sumw = h->Integral(first,last); if (sumw == 0) return; Double_t sumgen = 0; for (Int_t bin=first;bin<=last;bin++) { Double_t mean = h->GetBinContent(bin)*ntimes/sumw; Double_t cont = (Double_t)gRandom->Poisson(mean); sumgen += cont; AddBinContent(bin,cont); if (fSumw2.fN) fSumw2.fArray[bin] += cont; } // fix for the fluctations in the total number n // since we use Poisson instead of multinomial // add a correction to have ntimes as generated entries Int_t i; if (sumgen < ntimes) { // add missing entries for (i = Int_t(sumgen+0.5); i < ntimes; ++i) { Double_t x = h->GetRandom(); Fill(x); } } else if (sumgen > ntimes) { // remove extra entries i = Int_t(sumgen+0.5); while( i > ntimes) { Double_t x = h->GetRandom(); Int_t ibin = fXaxis.FindBin(x); Double_t y = GetBinContent(ibin); // skip in case bin is empty if (y > 0) { SetBinContent(ibin, y-1.); i--; } } } ResetStats(); return; } catch(std::exception&) {} // do nothing } // case of different axis and not too large ntimes if (h->ComputeIntegral() ==0) return; Int_t loop; Double_t x; for (loop=0;loop<ntimes;loop++) { x = h->GetRandom(); Fill(x); } } //______________________________________________________________________________ Int_t TH1::FindBin(Double_t x, Double_t y, Double_t z) { // Return Global bin number corresponding to x,y,z // =============================================== // // 2-D and 3-D histograms are represented with a one dimensional // structure. This function tries to rebin the axis if the given point // belongs to an under-/overflow bin. // This has the advantage that all existing functions, such as // GetBinContent, GetBinError, GetBinFunction work for all dimensions. // See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (GetDimension() < 2) { return fXaxis.FindBin(x); } if (GetDimension() < 3) { Int_t nx = fXaxis.GetNbins()+2; Int_t binx = fXaxis.FindBin(x); Int_t biny = fYaxis.FindBin(y); return binx + nx*biny; } if (GetDimension() < 4) { Int_t nx = fXaxis.GetNbins()+2; Int_t ny = fYaxis.GetNbins()+2; Int_t binx = fXaxis.FindBin(x); Int_t biny = fYaxis.FindBin(y); Int_t binz = fZaxis.FindBin(z); return binx + nx*(biny +ny*binz); } return -1; } //______________________________________________________________________________ Int_t TH1::FindFixBin(Double_t x, Double_t y, Double_t z) const { // Return Global bin number corresponding to x,y,z // =============================================== // // 2-D and 3-D histograms are represented with a one dimensional // structure. This function DOES not try to rebin the axis if the given // point belongs to an under-/overflow bin. // This has the advantage that all existing functions, such as // GetBinContent, GetBinError, GetBinFunction work for all dimensions. // See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (GetDimension() < 2) { return fXaxis.FindFixBin(x); } if (GetDimension() < 3) { Int_t nx = fXaxis.GetNbins()+2; Int_t binx = fXaxis.FindFixBin(x); Int_t biny = fYaxis.FindFixBin(y); return binx + nx*biny; } if (GetDimension() < 4) { Int_t nx = fXaxis.GetNbins()+2; Int_t ny = fYaxis.GetNbins()+2; Int_t binx = fXaxis.FindFixBin(x); Int_t biny = fYaxis.FindFixBin(y); Int_t binz = fZaxis.FindFixBin(z); return binx + nx*(biny +ny*binz); } return -1; } //______________________________________________________________________________ Int_t TH1::FindFirstBinAbove(Double_t threshold, Int_t axis) const { //find first bin with content > threshold for axis (1=x, 2=y, 3=z) //if no bins with content > threshold is found the function returns -1. if (axis != 1) { Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis); axis = 1; } Int_t nbins = fXaxis.GetNbins(); for (Int_t bin=1;bin<=nbins;bin++) { if (GetBinContent(bin) > threshold) return bin; } return -1; } //______________________________________________________________________________ Int_t TH1::FindLastBinAbove(Double_t threshold, Int_t axis) const { //find last bin with content > threshold for axis (1=x, 2=y, 3=z) //if no bins with content > threshold is found the function returns -1. if (axis != 1) { Warning("FindLastBinAbove","Invalid axis number : %d, axis x assumed\n",axis); axis = 1; } Int_t nbins = fXaxis.GetNbins(); for (Int_t bin=nbins;bin>=1;bin--) { if (GetBinContent(bin) > threshold) return bin; } return -1; } //______________________________________________________________________________ TObject *TH1::FindObject(const char *name) const { // search object named name in the list of functions if (fFunctions) return fFunctions->FindObject(name); return 0; } //______________________________________________________________________________ TObject *TH1::FindObject(const TObject *obj) const { // search object obj in the list of functions if (fFunctions) return fFunctions->FindObject(obj); return 0; } //______________________________________________________________________________ TFitResultPtr TH1::Fit(const char *fname ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax) { // Fit histogram with function fname // ================================= // fname is the name of an already predefined function created by TF1 or TF2 // Predefined functions such as gaus, expo and poln are automatically // created by ROOT. // fname can also be a formula, accepted by the linear fitter (linear parts divided // by "++" sign), for example "x++sin(x)" for fitting "[0]*x+[1]*sin(x)" // // This function finds a pointer to the TF1 object with name fname // and calls TH1::Fit(TF1 *f1,...) char *linear; linear= (char*)strstr(fname, "++"); TF1 *f1=0; TF2 *f2=0; TF3 *f3=0; Int_t ndim=GetDimension(); if (linear){ if (ndim<2){ f1=new TF1(fname, fname, xxmin, xxmax); return Fit(f1,option,goption,xxmin,xxmax); } else if (ndim<3){ f2=new TF2(fname, fname); return Fit(f2,option,goption,xxmin,xxmax); } else{ f3=new TF3(fname, fname); return Fit(f3,option,goption,xxmin,xxmax); } } else{ f1 = (TF1*)gROOT->GetFunction(fname); if (!f1) { Printf("Unknown function: %s",fname); return -1; } return Fit(f1,option,goption,xxmin,xxmax); } } //______________________________________________________________________________ TFitResultPtr TH1::Fit(TF1 *f1 ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax) { // Fit histogram with function f1 // ============================== // // Fit this histogram with function f1. // // The list of fit options is given in parameter option. // option = "W" Set all weights to 1 for non empty bins; ignore error bars // = "WW" Set all weights to 1 including empty bins; ignore error bars // = "I" Use integral of function in bin, normalized by the bin volume, // instead of value at bin center // = "L" Use Loglikelihood method (default is chisquare method) // = "WL" Use Loglikelihood method and bin contents are not integer, // i.e. histogram is weighted (must have Sumw2() set) // = "U" Use a User specified fitting algorithm (via SetFCN) // = "Q" Quiet mode (minimum printing) // = "V" Verbose mode (default is between Q and V) // = "E" Perform better Errors estimation using Minos technique // = "B" User defined parameter settings are used for predefined functions // like "gaus", "expo", "poln", "landau". // Use this option when you want to fix one or more parameters for these functions. // = "M" More. Improve fit results. // It uses the IMPROVE command of TMinuit (see TMinuit::mnimpr). // This algorithm attempts to improve the found local minimum by searching for a // better one. // = "R" Use the Range specified in the function range // = "N" Do not store the graphics function, do not draw // = "0" Do not plot the result of the fit. By default the fitted function // is drawn unless the option"N" above is specified. // = "+" Add this new fitted function to the list of fitted functions // (by default, any previous function is deleted) // = "C" In case of linear fitting, don't calculate the chisquare // (saves time) // = "F" If fitting a polN, switch to minuit fitter // = "S" The result of the fit is returned in the TFitResultPtr // (see below Access to the Fit Result) // // When the fit is drawn (by default), the parameter goption may be used // to specify a list of graphics options. See TH1::Draw for a complete // list of these options. // // In order to use the Range option, one must first create a function // with the expression to be fitted. For example, if your histogram // has a defined range between -4 and 4 and you want to fit a gaussian // only in the interval 1 to 3, you can do: // TF1 *f1 = new TF1("f1", "gaus", 1, 3); // histo->Fit("f1", "R"); // // Setting initial conditions // ========================== // Parameters must be initialized before invoking the Fit function. // The setting of the parameter initial values is automatic for the // predefined functions : poln, expo, gaus, landau. One can however disable // this automatic computation by specifying the option "B". // Note that if a predefined function is defined with an argument, // eg, gaus(0), expo(1), you must specify the initial values for // the parameters. // You can specify boundary limits for some or all parameters via // f1->SetParLimits(p_number, parmin, parmax); // if parmin>=parmax, the parameter is fixed // Note that you are not forced to fix the limits for all parameters. // For example, if you fit a function with 6 parameters, you can do: // func->SetParameters(0, 3.1, 1.e-6, -8, 0, 100); // func->SetParLimits(3, -10, -4); // func->FixParameter(4, 0); // func->SetParLimits(5, 1, 1); // With this setup, parameters 0->2 can vary freely // Parameter 3 has boundaries [-10,-4] with initial value -8 // Parameter 4 is fixed to 0 // Parameter 5 is fixed to 100. // When the lower limit and upper limit are equal, the parameter is fixed. // However to fix a parameter to 0, one must call the FixParameter function. // // Note that option "I" gives better results but is slower. // // // Changing the fitting objective function // ============================= // By default a chi square function is used for fitting. When option "L" (or "LL") is used // a Poisson likelihood function (see note below) is used. // The functions are defined in the header Fit/Chi2Func.h or Fit/PoissonLikelihoodFCN and they // are implemented using the routines FitUtil::EvaluateChi2 or FitUtil::EvaluatePoissonLogL in // the file math/mathcore/src/FitUtil.cxx. // To specify a User defined fitting function, specify option "U" and // call the following functions: // TVirtualFitter::Fitter(myhist)->SetFCN(MyFittingFunction) // where MyFittingFunction is of type: // extern void MyFittingFunction(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag); // // Likelihood Fits // ================= // When using option "L" a likelihood fit is used instead of the default chi2 square fit. // The likelihood is built assuming a Poisson probability density function for each bin. // This method can then be used only when the bin content represents counts (i.e. errors are sqrt(N) ). // The likelihood method has the advantage of treating correctly the empty bins and use them in the // fit procedure. // In the chi2 method the empty bins are skipped and not considered in the fit. // The likelihood method, although a bit slower, it is the recommended method in case of low // bin statistics, where the chi2 method may give incorrect results. // // Fitting a histogram of dimension N with a function of dimension N-1 // =================================================================== // It is possible to fit a TH2 with a TF1 or a TH3 with a TF2. // In this case the option "Integral" is not allowed and each cell has // equal weight. // // Associated functions // ==================== // One or more object (typically a TF1*) can be added to the list // of functions (fFunctions) associated to each histogram. // When TH1::Fit is invoked, the fitted function is added to this list. // Given an histogram h, one can retrieve an associated function // with: TF1 *myfunc = h->GetFunction("myfunc"); // // Access to the fit result // ======================== // The function returns a TFitResultPtr which can hold a pointer to a TFitResult object. // By default the TFitResultPtr contains only the status of the fit which is return by an // automatic conversion of the TFitResultPtr to an integer. One can write in this case directly: // Int_t fitStatus = h->Fit(myFunc) // // If the option "S" is instead used, TFitResultPtr contains the TFitResult and behaves as a smart // pointer to it. For example one can do: // TFitResultPtr r = h->Fit(myFunc,"S"); // TMatrixDSym cov = r->GetCovarianceMatrix(); // to access the covariance matrix // Double_t chi2 = r->Chi2(); // to retrieve the fit chi2 // Double_t par0 = r->Parameter(0); // retrieve the value for the parameter 0 // Double_t err0 = r->ParError(0); // retrieve the error for the parameter 0 // r->Print("V"); // print full information of fit including covariance matrix // r->Write(); // store the result in a file // // The fit parameters, error and chi2 (but not covariance matrix) can be retrieved also // from the fitted function. // If the histogram is made persistent, the list of // associated functions is also persistent. Given a pointer (see above) // to an associated function myfunc, one can retrieve the function/fit // parameters with calls such as: // Double_t chi2 = myfunc->GetChisquare(); // Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter // Double_t err0 = myfunc->GetParError(0); //error on first parameter // // // Access to the fit status // ===================== // The status of the fit can be obtained converting the TFitResultPtr to an integer // independently if the fit option "S" is used or not: // TFitResultPtr r = h->Fit(myFunc,opt); // Int_t fitStatus = r; // // The fitStatus is 0 if the fit is OK (i.e no error occurred). // The value of the fit status code is negative in case of an error not connected with the // minimization procedure, for example when a wrong function is used. // Otherwise the return value is the one returned from the minimization procedure. // When TMinuit (default case) or Minuit2 are used as minimizer the status returned is : // fitStatus = migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult. // TMinuit will return 0 (for migrad, minos, hesse or improve) in case of success and 4 in // case of error (see the documentation of TMinuit::mnexcm). So for example, for an error // only in Minos but not in Migrad a fitStatus of 40 will be returned. // Minuit2 will return also 0 in case of success and different values in migrad minos or // hesse depending on the error. See in this case the documentation of // Minuit2Minimizer::Minimize for the migradResult, Minuit2Minimizer::GetMinosError for the // minosResult and Minuit2Minimizer::Hesse for the hesseResult. // If other minimizers are used see their specific documentation for the status code returned. // For example in the case of Fumili, for the status returned see TFumili::Minimize. // // Excluding points // ================ // Use TF1::RejectPoint inside your fitting function to exclude points // within a certain range from the fit. Example: // Double_t fline(Double_t *x, Double_t *par) // { // if (x[0] > 2.5 && x[0] < 3.5) { // TF1::RejectPoint(); // return 0; // } // return par[0] + par[1]*x[0]; // } // // void exclude() { // TF1 *f1 = new TF1("f1", "[0] +[1]*x +gaus(2)", 0, 5); // f1->SetParameters(6, -1,5, 3, 0.2); // TH1F *h = new TH1F("h", "background + signal", 100, 0, 5); // h->FillRandom("f1", 2000); // TF1 *fline = new TF1("fline", fline, 0, 5, 2); // fline->SetParameters(2, -1); // h->Fit("fline", "l"); // } // // Warning when using the option "0" // ================================= // When selecting the option "0", the fitted function is added to // the list of functions of the histogram, but it is not drawn. // You can undo what you disabled in the following way: // h.Fit("myFunction", "0"); // fit, store function but do not draw // h.Draw(); function is not drawn // const Int_t kNotDraw = 1<<9; // h.GetFunction("myFunction")->ResetBit(kNotDraw); // h.Draw(); // function is visible again // // Access to the Minimizer information during fitting // =============================================== // This function calls, the ROOT::Fit::FitObject function implemented in HFitImpl.cxx // which uses the ROOT::Fit::Fitter class. The Fitter class creates the objective fuction // (e.g. chi2 or likelihood) and uses an implementation of the Minimizer interface for minimizing // the function. // The default minimizer is Minuit (class TMinuitMinimizer which calls TMinuit). // The default can be set in the resource file in etc/system.rootrc. For example // Root.Fitter: Minuit2 // A different fitter can also be set via ROOT::Math::MinimizerOptions::SetDefaultMinimizer // (or TVirtualFitter::SetDefaultFitter). // For example ROOT::Math::MinimizerOptions::SetDefaultMinimizer("GSLMultiMin","BFGS"); // will set the usdage of the BFGS algorithm of the GSL multi-dimensional minimization // (implemented in libMathMore). ROOT::Math::MinimizerOptions can be used also to set other // default options, like maximum number of function calls, minimization tolerance or print // level. See the documentation of this class. // // For fitting linear functions (containing the "++" sign" and polN functions, // the linear fitter is automatically initialized. // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* // implementation of Fit method is in file hist/src/HFitImpl.cxx Foption_t fitOption; if (!FitOptionsMake(option,fitOption)) return 0; // create range and minimizer options with default values ROOT::Fit::DataRange range(xxmin,xxmax); ROOT::Math::MinimizerOptions minOption; // need to empty the buffer before // (t.b.d. do a ML unbinned fit with buffer data) if (fBuffer) BufferEmpty(); return ROOT::Fit::FitObject(this, f1 , fitOption , minOption, goption, range); } //______________________________________________________________________________ void TH1::FitPanel() { // -*-*-*-*-*Display a panel with all histogram fit options*-*-*-*-*-* // ============================================== // // See class TFitPanel for example if (!gPad) gROOT->MakeDefCanvas(); if (!gPad) { Error("FitPanel", "Unable to create a default canvas"); return; } // use plugin manager to create instance of TFitEditor TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor"); if (handler && handler->LoadPlugin() != -1) { if (handler->ExecPlugin(2, gPad, this) == 0) Error("FitPanel", "Unable to create the FitPanel"); } else Error("FitPanel", "Unable to find the FitPanel plug-in"); } //______________________________________________________________________________ TH1 *TH1::GetAsymmetry(TH1* h2, Double_t c2, Double_t dc2) { // return an histogram containing the asymmetry of this histogram with h2, // where the asymmetry is defined as: // // Asymmetry = (h1 - h2)/(h1 + h2) where h1 = this // // works for 1D, 2D, etc. histograms // c2 is an optional argument that gives a relative weight between the two // histograms, and dc2 is the error on this weight. This is useful, for example, // when forming an asymmetry between two histograms from 2 different data sets that // need to be normalized to each other in some way. The function calculates // the errors asumming Poisson statistics on h1 and h2 (that is, dh = sqrt(h)). // // example: assuming 'h1' and 'h2' are already filled // // h3 = h1->GetAsymmetry(h2) // // then 'h3' is created and filled with the asymmetry between 'h1' and 'h2'; // h1 and h2 are left intact. // // Note that it is the user's responsibility to manage the created histogram. // // code proposed by Jason Seely (seely@mit.edu) and adapted by R.Brun // // clone the histograms so top and bottom will have the // correct dimensions: // Sumw2 just makes sure the errors will be computed properly // when we form sums and ratios below. Bool_t addStatus = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); TH1 *asym = (TH1*)Clone(); asym->Sumw2(); TH1 *top = (TH1*)asym->Clone(); TH1 *bottom = (TH1*)asym->Clone(); TH1::AddDirectory(addStatus); // form the top and bottom of the asymmetry, and then divide: TH1 *h1 = this; top->Add(h1,h2,1,-c2); bottom->Add(h1,h2,1,c2); asym->Divide(top,bottom); Int_t xmax = asym->GetNbinsX(); Int_t ymax = asym->GetNbinsY(); Int_t zmax = asym->GetNbinsZ(); Double_t bot, error, a, b, da, db; // now loop over bins to calculate the correct errors // the reason this error calculation looks complex is because of c2 for(Int_t i=1; i<= xmax; i++){ for(Int_t j=1; j<= ymax; j++){ for(Int_t k=1; k<= zmax; k++){ // here some bin contents are written into variables to make the error // calculation a little more legible: a = h1->GetBinContent(i,j,k); b = h2->GetBinContent(i,j,k); bot = bottom->GetBinContent(i,j,k); // make sure there are some events, if not, then the errors are set = 0 // automatically. //if(bot < 1){} was changed to the next line from recommendation of Jason Seely (28 Nov 2005) if(bot < 1e-6){} else{ // computation of errors by Christos Leonidopoulos da = h1->GetBinError(i,j,k); db = h2->GetBinError(i,j,k); error = 2*TMath::Sqrt(a*a*c2*c2*db*db + c2*c2*b*b*da*da+a*a*b*b*dc2*dc2)/(bot*bot); asym->SetBinError(i,j,k,error); } } } } delete top; delete bottom; return asym; } //______________________________________________________________________________ Int_t TH1::GetDefaultBufferSize() { // static function // return the default buffer size for automatic histograms // the parameter fgBufferSize may be changed via SetDefaultBufferSize return fgBufferSize; } //______________________________________________________________________________ Bool_t TH1::GetDefaultSumw2() { // static function // return kTRUE if TH1::Sumw2 must be called when creating new histograms. // see TH1::SetDefaultSumw2. return fgDefaultSumw2; } //______________________________________________________________________________ Double_t TH1::GetEntries() const { // return the current number of entries if (fBuffer) { Int_t nentries = (Int_t) fBuffer[0]; if (nentries > 0) return nentries; } return fEntries; } //______________________________________________________________________________ Double_t TH1::GetEffectiveEntries() const { // number of effective entries of the histogram, // neff = (Sum of weights )^2 / (Sum of weight^2 ) // In case of an unweighted histogram this number is equivalent to the // number of entries of the histogram. // For a weighted histogram, this number corresponds to the hypotetical number of unweighted entries // a histogram would need to have the same statistical power as this weighted histogram. // Note: The underflow/overflow are included if one has set the TH1::StatOverFlows flag // and if the statistics has been computed at filling time. // If a range is set in the histogram the number is computed from the given range. Stat_t s[kNstat]; this->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights return (s[1] ? s[0]*s[0]/s[1] : TMath::Abs(s[0]) ); } //______________________________________________________________________________ char *TH1::GetObjectInfo(Int_t px, Int_t py) const { // Redefines TObject::GetObjectInfo. // Displays the histogram info (bin number, contents, integral up to bin // corresponding to cursor position px,py // return ((TH1*)this)->GetPainter()->GetObjectInfo(px,py); } //______________________________________________________________________________ TVirtualHistPainter *TH1::GetPainter(Option_t *option) { // return pointer to painter // if painter does not exist, it is created if (!fPainter) { TString opt = option; opt.ToLower(); if (opt.Contains("gl") || gStyle->GetCanvasPreferGL()) { //try to create TGLHistPainter TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TGLHistPainter"); if (handler && handler->LoadPlugin() != -1) fPainter = reinterpret_cast<TVirtualHistPainter *>(handler->ExecPlugin(1, this)); } } if (!fPainter) fPainter = TVirtualHistPainter::HistPainter(this); return fPainter; } //______________________________________________________________________________ Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum) { // Compute Quantiles for this histogram // Quantile x_q of a probability distribution Function F is defined as // // F(x_q) = q with 0 <= q <= 1. // // For instance the median x_0.5 of a distribution is defined as that value // of the random variable for which the distribution function equals 0.5: // // F(x_0.5) = Probability(x < x_0.5) = 0.5 // // code from Eddy Offermann, Renaissance // // input parameters // - this 1-d histogram (TH1F,D,etc). Could also be a TProfile // - nprobSum maximum size of array q and size of array probSum (if given) // - probSum array of positions where quantiles will be computed. // if probSum is null, probSum will be computed internally and will // have a size = number of bins + 1 in h. it will correspond to the // quantiles calculated at the lowest edge of the histogram (quantile=0) and // all the upper edges of the bins. // if probSum is not null, it is assumed to contain at least nprobSum values. // output // - return value nq (<=nprobSum) with the number of quantiles computed // - array q filled with nq quantiles // // Note that the Integral of the histogram is automatically recomputed // if the number of entries is different of the number of entries when // the integral was computed last time. In case you do not use the Fill // functions to fill your histogram, but SetBinContent, you must call // TH1::ComputeIntegral before calling this function. // // Getting quantiles q from two histograms and storing results in a TGraph, // a so-called QQ-plot // // TGraph *gr = new TGraph(nprob); // h1->GetQuantiles(nprob,gr->GetX()); // h2->GetQuantiles(nprob,gr->GetY()); // gr->Draw("alp"); // // Example: // void quantiles() { // // demo for quantiles // const Int_t nq = 20; // TH1F *h = new TH1F("h","demo quantiles",100,-3,3); // h->FillRandom("gaus",5000); // // Double_t xq[nq]; // position where to compute the quantiles in [0,1] // Double_t yq[nq]; // array to contain the quantiles // for (Int_t i=0;i<nq;i++) xq[i] = Float_t(i+1)/nq; // h->GetQuantiles(nq,yq,xq); // // //show the original histogram in the top pad // TCanvas *c1 = new TCanvas("c1","demo quantiles",10,10,700,900); // c1->Divide(1,2); // c1->cd(1); // h->Draw(); // // // show the quantiles in the bottom pad // c1->cd(2); // gPad->SetGrid(); // TGraph *gr = new TGraph(nq,xq,yq); // gr->SetMarkerStyle(21); // gr->Draw("alp"); // } if (GetDimension() > 1) { Error("GetQuantiles","Only available for 1-d histograms"); return 0; } const Int_t nbins = GetXaxis()->GetNbins(); if (!fIntegral) ComputeIntegral(); if (fIntegral[nbins+1] != fEntries) ComputeIntegral(); Int_t i, ibin; Double_t *prob = (Double_t*)probSum; Int_t nq = nprobSum; if (probSum == 0) { nq = nbins+1; prob = new Double_t[nq]; prob[0] = 0; for (i=1;i<nq;i++) { prob[i] = fIntegral[i]/fIntegral[nbins]; } } for (i = 0; i < nq; i++) { ibin = TMath::BinarySearch(nbins,fIntegral,prob[i]); while (ibin < nbins-1 && fIntegral[ibin+1] == prob[i]) { if (fIntegral[ibin+2] == prob[i]) ibin++; else break; } q[i] = GetBinLowEdge(ibin+1); const Double_t dint = fIntegral[ibin+1]-fIntegral[ibin]; if (dint > 0) q[i] += GetBinWidth(ibin+1)*(prob[i]-fIntegral[ibin])/dint; } if (!probSum) delete [] prob; return nq; } //______________________________________________________________________________ Int_t TH1::FitOptionsMake(Option_t *choptin, Foption_t &fitOption) { // -*-*-*-*-*-*-*Decode string choptin and fill fitOption structure*-*-*-*-*-* // ================================================ if (choptin == 0) return 1; if (strlen(choptin) == 0) return 1; TString opt = choptin; opt.ToUpper(); if (opt.Contains("Q")) fitOption.Quiet = 1; if (opt.Contains("V")) {fitOption.Verbose = 1; fitOption.Quiet = 0;} if (opt.Contains("X")) fitOption.Chi2 = 1; if (opt.Contains("W")) fitOption.W1 = 1; if (opt.Contains("WW")) fitOption.W1 = 2; //all bins have weight=1, even empty bins // likelihood fit options if (opt.Contains("L")) { fitOption.Like = 1; //if (opt.Contains("LL")) fitOption.Like = 2; if (opt.Contains("W")){ fitOption.Like = 2; fitOption.W1=0;}// (weighted likelihood) if (opt.Contains("MULTI")) { if (fitOption.Like == 2) fitOption.Like = 6; // weighted multinomial else fitOption.Like = 4; // multinomial likelihood fit instead of Poisson opt.ReplaceAll("MULTI",""); } } if (opt.Contains("E")) fitOption.Errors = 1; if (opt.Contains("M")) fitOption.More = 1; if (opt.Contains("R")) fitOption.Range = 1; if (opt.Contains("G")) fitOption.Gradient= 1; if (opt.Contains("N")) fitOption.Nostore = 1; if (opt.Contains("0")) fitOption.Nograph = 1; if (opt.Contains("+")) fitOption.Plus = 1; if (opt.Contains("I")) fitOption.Integral= 1; if (opt.Contains("B")) fitOption.Bound = 1; if (opt.Contains("U")) {fitOption.User = 1; fitOption.Like = 0;} if (opt.Contains("F")) fitOption.Minuit = 1; if (opt.Contains("C")) fitOption.Nochisq = 1; if (opt.Contains("S")) fitOption.StoreResult = 1; return 1; } //______________________________________________________________________________ void H1InitGaus() { // -*-*-*-*Compute Initial values of parameters for a gaussian*-*-*-*-*-*-* // =================================================== Double_t allcha, sumx, sumx2, x, val, rms, mean; Int_t bin; const Double_t sqrtpi = 2.506628; // - Compute mean value and RMS of the histogram in the given range TVirtualFitter *hFitter = TVirtualFitter::GetFitter(); TH1 *curHist = (TH1*)hFitter->GetObjectFit(); Int_t hxfirst = hFitter->GetXfirst(); Int_t hxlast = hFitter->GetXlast(); Double_t valmax = curHist->GetBinContent(hxfirst); Double_t binwidx = curHist->GetBinWidth(hxfirst); allcha = sumx = sumx2 = 0; for (bin=hxfirst;bin<=hxlast;bin++) { x = curHist->GetBinCenter(bin); val = TMath::Abs(curHist->GetBinContent(bin)); if (val > valmax) valmax = val; sumx += val*x; sumx2 += val*x*x; allcha += val; } if (allcha == 0) return; mean = sumx/allcha; rms = sumx2/allcha - mean*mean; if (rms > 0) rms = TMath::Sqrt(rms); else rms = 0; if (rms == 0) rms = binwidx*(hxlast-hxfirst+1)/4; //if the distribution is really gaussian, the best approximation //is binwidx*allcha/(sqrtpi*rms) //However, in case of non-gaussian tails, this underestimates //the normalisation constant. In this case the maximum value //is a better approximation. //We take the average of both quantities Double_t constant = 0.5*(valmax+binwidx*allcha/(sqrtpi*rms)); //In case the mean value is outside the histo limits and //the RMS is bigger than the range, we take // mean = center of bins // rms = half range Double_t xmin = curHist->GetXaxis()->GetXmin(); Double_t xmax = curHist->GetXaxis()->GetXmax(); if ((mean < xmin || mean > xmax) && rms > (xmax-xmin)) { mean = 0.5*(xmax+xmin); rms = 0.5*(xmax-xmin); } TF1 *f1 = (TF1*)hFitter->GetUserFunc(); f1->SetParameter(0,constant); f1->SetParameter(1,mean); f1->SetParameter(2,rms); f1->SetParLimits(2,0,10*rms); } //______________________________________________________________________________ void H1InitExpo() { // -*-*-*-*Compute Initial values of parameters for an exponential*-*-*-*-* // ======================================================= Double_t constant, slope; Int_t ifail; TVirtualFitter *hFitter = TVirtualFitter::GetFitter(); Int_t hxfirst = hFitter->GetXfirst(); Int_t hxlast = hFitter->GetXlast(); Int_t nchanx = hxlast - hxfirst + 1; H1LeastSquareLinearFit(-nchanx, constant, slope, ifail); TF1 *f1 = (TF1*)hFitter->GetUserFunc(); f1->SetParameter(0,constant); f1->SetParameter(1,slope); } //______________________________________________________________________________ void H1InitPolynom() { // -*-*-*-*Compute Initial values of parameters for a polynom*-*-*-*-*-*-* // =================================================== Double_t fitpar[25]; TVirtualFitter *hFitter = TVirtualFitter::GetFitter(); TF1 *f1 = (TF1*)hFitter->GetUserFunc(); Int_t hxfirst = hFitter->GetXfirst(); Int_t hxlast = hFitter->GetXlast(); Int_t nchanx = hxlast - hxfirst + 1; Int_t npar = f1->GetNpar(); if (nchanx <=1 || npar == 1) { TH1 *curHist = (TH1*)hFitter->GetObjectFit(); fitpar[0] = curHist->GetSumOfWeights()/Double_t(nchanx); } else { H1LeastSquareFit( nchanx, npar, fitpar); } for (Int_t i=0;i<npar;i++) f1->SetParameter(i, fitpar[i]); } //______________________________________________________________________________ void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a) { // -*-*-*-*-*-*Least squares lpolynomial fitting without weights*-*-*-*-*-*-* // ================================================= // // n number of points to fit // m number of parameters // a array of parameters // // based on CERNLIB routine LSQ: Translated to C++ by Rene Brun // (E.Keil. revised by B.Schorr, 23.10.1981.) // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* const Double_t zero = 0.; const Double_t one = 1.; const Int_t idim = 20; Double_t b[400] /* was [20][20] */; Int_t i, k, l, ifail; Double_t power; Double_t da[20], xk, yk; if (m <= 2) { H1LeastSquareLinearFit(n, a[0], a[1], ifail); return; } if (m > idim || m > n) return; b[0] = Double_t(n); da[0] = zero; for (l = 2; l <= m; ++l) { b[l-1] = zero; b[m + l*20 - 21] = zero; da[l-1] = zero; } TVirtualFitter *hFitter = TVirtualFitter::GetFitter(); TH1 *curHist = (TH1*)hFitter->GetObjectFit(); Int_t hxfirst = hFitter->GetXfirst(); Int_t hxlast = hFitter->GetXlast(); for (k = hxfirst; k <= hxlast; ++k) { xk = curHist->GetBinCenter(k); yk = curHist->GetBinContent(k); power = one; da[0] += yk; for (l = 2; l <= m; ++l) { power *= xk; b[l-1] += power; da[l-1] += power*yk; } for (l = 2; l <= m; ++l) { power *= xk; b[m + l*20 - 21] += power; } } for (i = 3; i <= m; ++i) { for (k = i; k <= m; ++k) { b[k - 1 + (i-1)*20 - 21] = b[k + (i-2)*20 - 21]; } } H1LeastSquareSeqnd(m, b, idim, ifail, 1, da); for (i=0; i<m; ++i) a[i] = da[i]; } //______________________________________________________________________________ void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail) { // -*-*-*-*-*-*-*-*Least square linear fit without weights*-*-*-*-*-*-*-*-* // ======================================= // // extracted from CERNLIB LLSQ: Translated to C++ by Rene Brun // (added to LSQ by B. Schorr, 15.02.1982.) // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Double_t xbar, ybar, x2bar; Int_t i, n; Double_t xybar; Double_t fn, xk, yk; Double_t det; n = TMath::Abs(ndata); ifail = -2; xbar = ybar = x2bar = xybar = 0; TVirtualFitter *hFitter = TVirtualFitter::GetFitter(); TH1 *curHist = (TH1*)hFitter->GetObjectFit(); Int_t hxfirst = hFitter->GetXfirst(); Int_t hxlast = hFitter->GetXlast(); for (i = hxfirst; i <= hxlast; ++i) { xk = curHist->GetBinCenter(i); yk = curHist->GetBinContent(i); if (ndata < 0) { if (yk <= 0) yk = 1e-9; yk = TMath::Log(yk); } xbar += xk; ybar += yk; x2bar += xk*xk; xybar += xk*yk; } fn = Double_t(n); det = fn*x2bar - xbar*xbar; ifail = -1; if (det <= 0) { a0 = ybar/fn; a1 = 0; return; } ifail = 0; a0 = (x2bar*ybar - xbar*xybar) / det; a1 = (fn*xybar - xbar*ybar) / det; } //______________________________________________________________________________ void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b) { // -*-*-*-*-*-*Extracted from CERN Program library routine DSEQN*-*-*-*-*-* // ================================================= // // : Translated to C++ by Rene Brun // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Int_t a_dim1, a_offset, b_dim1, b_offset; Int_t nmjp1, i, j, l; Int_t im1, jp1, nm1, nmi; Double_t s1, s21, s22; const Double_t one = 1.; /* Parameter adjustments */ b_dim1 = idim; b_offset = b_dim1 + 1; b -= b_offset; a_dim1 = idim; a_offset = a_dim1 + 1; a -= a_offset; if (idim < n) return; ifail = 0; for (j = 1; j <= n; ++j) { if (a[j + j*a_dim1] <= 0) { ifail = -1; return; } a[j + j*a_dim1] = one / a[j + j*a_dim1]; if (j == n) continue; jp1 = j + 1; for (l = jp1; l <= n; ++l) { a[j + l*a_dim1] = a[j + j*a_dim1] * a[l + j*a_dim1]; s1 = -a[l + (j+1)*a_dim1]; for (i = 1; i <= j; ++i) { s1 = a[l + i*a_dim1] * a[i + (j+1)*a_dim1] + s1; } a[l + (j+1)*a_dim1] = -s1; } } if (k <= 0) return; for (l = 1; l <= k; ++l) { b[l*b_dim1 + 1] = a[a_dim1 + 1]*b[l*b_dim1 + 1]; } if (n == 1) return; for (l = 1; l <= k; ++l) { for (i = 2; i <= n; ++i) { im1 = i - 1; s21 = -b[i + l*b_dim1]; for (j = 1; j <= im1; ++j) { s21 = a[i + j*a_dim1]*b[j + l*b_dim1] + s21; } b[i + l*b_dim1] = -a[i + i*a_dim1]*s21; } nm1 = n - 1; for (i = 1; i <= nm1; ++i) { nmi = n - i; s22 = -b[nmi + l*b_dim1]; for (j = 1; j <= i; ++j) { nmjp1 = n - j + 1; s22 = a[nmi + nmjp1*a_dim1]*b[nmjp1 + l*b_dim1] + s22; } b[nmi + l*b_dim1] = -s22; } } } //______________________________________________________________________________ Int_t TH1::GetBin(Int_t binx, Int_t biny, Int_t binz) const { // -*-*-*-*Return Global bin number corresponding to binx,y,z*-*-*-*-*-*-* // ================================================== // // 2-D and 3-D histograms are represented with a one dimensional // structure. // This has the advantage that all existing functions, such as // GetBinContent, GetBinError, GetBinFunction work for all dimensions. // // In case of a TH1x, returns binx directly. // see TH1::GetBinXYZ for the inverse transformation. // // Convention for numbering bins // ============================= // For all histogram types: nbins, xlow, xup // bin = 0; underflow bin // bin = 1; first bin with low-edge xlow INCLUDED // bin = nbins; last bin with upper-edge xup EXCLUDED // bin = nbins+1; overflow bin // In case of 2-D or 3-D histograms, a "global bin" number is defined. // For example, assuming a 3-D histogram with binx,biny,binz, the function // Int_t bin = h->GetBin(binx,biny,binz); // returns a global/linearized bin number. This global bin is useful // to access the bin information independently of the dimension. // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* Int_t nx, ny, nz; if (GetDimension() < 2) { nx = fXaxis.GetNbins()+2; if (binx < 0) binx = 0; if (binx >= nx) binx = nx-1; return binx; } if (GetDimension() < 3) { nx = fXaxis.GetNbins()+2; if (binx < 0) binx = 0; if (binx >= nx) binx = nx-1; ny = fYaxis.GetNbins()+2; if (biny < 0) biny = 0; if (biny >= ny) biny = ny-1; return binx + nx*biny; } if (GetDimension() < 4) { nx = fXaxis.GetNbins()+2; if (binx < 0) binx = 0; if (binx >= nx) binx = nx-1; ny = fYaxis.GetNbins()+2; if (biny < 0) biny = 0; if (biny >= ny) biny = ny-1; nz = fZaxis.GetNbins()+2; if (binz < 0) binz = 0; if (binz >= nz) binz = nz-1; return binx + nx*(biny +ny*binz); } return -1; } //______________________________________________________________________________ void TH1::GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const { // return binx, biny, binz corresponding to the global bin number globalbin // see TH1::GetBin function above Int_t nx = fXaxis.GetNbins()+2; Int_t ny = fYaxis.GetNbins()+2; if (GetDimension() < 2) { binx = binglobal%nx; biny = -1; binz = -1; } if (GetDimension() < 3) { binx = binglobal%nx; biny = ((binglobal-binx)/nx)%ny; binz = -1; } if (GetDimension() < 4) { binx = binglobal%nx; biny = ((binglobal-binx)/nx)%ny; binz = ((binglobal-binx)/nx -biny)/ny; } } //______________________________________________________________________________ Double_t TH1::GetRandom() const { // return a random number distributed according the histogram bin contents. // This function checks if the bins integral exists. If not, the integral // is evaluated, normalized to one. // The integral is automatically recomputed if the number of entries // is not the same then when the integral was computed. // NB Only valid for 1-d histograms. Use GetRandom2 or 3 otherwise. // If the histogram has a bin with negative content a NaN is returned if (fDimension > 1) { Error("GetRandom","Function only valid for 1-d histograms"); return 0; } Int_t nbinsx = GetNbinsX(); Double_t integral = 0; // compute integral checking that all bins have positive content (see ROOT-5894) if (fIntegral) { if (fIntegral[nbinsx+1] != fEntries) integral = ((TH1*)this)->ComputeIntegral(true); else integral = fIntegral[nbinsx]; } else { integral = ((TH1*)this)->ComputeIntegral(true); } if (integral == 0) return 0; // return a NaN in case some bins have negative content if (integral == TMath::QuietNaN() ) return TMath::QuietNaN(); Double_t r1 = gRandom->Rndm(); Int_t ibin = TMath::BinarySearch(nbinsx,fIntegral,r1); Double_t x = GetBinLowEdge(ibin+1); if (r1 > fIntegral[ibin]) x += GetBinWidth(ibin+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]); return x; } //______________________________________________________________________________ Double_t TH1::GetBinContent(Int_t) const { // -*-*-*-*-*Return content of bin number bin // ================================ // Implemented in TH1C,S,F,D // // Convention for numbering bins // ============================= // For all histogram types: nbins, xlow, xup // bin = 0; underflow bin // bin = 1; first bin with low-edge xlow INCLUDED // bin = nbins; last bin with upper-edge xup EXCLUDED // bin = nbins+1; overflow bin // In case of 2-D or 3-D histograms, a "global bin" number is defined. // For example, assuming a 3-D histogram with binx,biny,binz, the function // Int_t bin = h->GetBin(binx,biny,binz); // returns a global/linearized bin number. This global bin is useful // to access the bin information independently of the dimension. AbstractMethod("GetBinContent"); return 0; } //______________________________________________________________________________ Double_t TH1::GetBinContent(Int_t binx, Int_t biny) const { // -*-*-*-*-*Return content of bin number binx, biny // ======================================= // NB: Function to be called for 2-D histograms only // see convention for numbering bins in TH1::GetBin Int_t bin = GetBin(binx,biny); return GetBinContent(bin); } //______________________________________________________________________________ Double_t TH1::GetBinContent(Int_t binx, Int_t biny, Int_t binz) const { // -*-*-*-*-*Return content of bin number binx,biny,binz // =========================================== // NB: Function to be called for 3-D histograms only // see convention for numbering bins in TH1::GetBin Int_t bin = GetBin(binx,biny,binz); return GetBinContent(bin); } //______________________________________________________________________________ Double_t TH1::GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx, Int_t lastx,Double_t maxdiff) const { // compute first binx in the range [firstx,lastx] for which // diff = abs(bin_content-c) <= maxdiff // In case several bins in the specified range with diff=0 are found // the first bin found is returned in binx. // In case several bins in the specified range satisfy diff <=maxdiff // the bin with the smallest difference is returned in binx. // In all cases the function returns the smallest difference. // // NOTE1: if firstx <= 0, firstx is set to bin 1 // if (lastx < firstx then firstx is set to the number of bins // ie if firstx=0 and lastx=0 (default) the search is on all bins. // NOTE2: if maxdiff=0 (default), the first bin with content=c is returned. if (fDimension > 1) { binx = 0; Error("GetBinWithContent","function is only valid for 1-D histograms"); return 0; } if (firstx <= 0) firstx = 1; if (lastx < firstx) lastx = fXaxis.GetNbins(); Int_t binminx = 0; Double_t diff, curmax = 1.e240; for (Int_t i=firstx;i<=lastx;i++) { diff = TMath::Abs(GetBinContent(i)-c); if (diff <= 0) {binx = i; return diff;} if (diff < curmax && diff <= maxdiff) {curmax = diff, binminx=i;} } binx = binminx; return curmax; } //______________________________________________________________________________ TAxis *TH1::GetXaxis() const { // return a pointer to the X axis object return &((TH1*)this)->fXaxis; } //______________________________________________________________________________ TAxis *TH1::GetYaxis() const { // return a pointer to the Y axis object return &((TH1*)this)->fYaxis; } //______________________________________________________________________________ TAxis *TH1::GetZaxis() const { // return a pointer to the Z axis object return &((TH1*)this)->fZaxis; } //______________________________________________________________________________ Double_t TH1::Interpolate(Double_t x) { // Given a point x, approximates the value via linear interpolation // based on the two nearest bin centers // Andy Mastbaum 10/21/08 Int_t xbin = FindBin(x); Double_t x0,x1,y0,y1; if(x<=GetBinCenter(1)) { return GetBinContent(1); } else if(x>=GetBinCenter(GetNbinsX())) { return GetBinContent(GetNbinsX()); } else { if(x<=GetBinCenter(xbin)) { y0 = GetBinContent(xbin-1); x0 = GetBinCenter(xbin-1); y1 = GetBinContent(xbin); x1 = GetBinCenter(xbin); } else { y0 = GetBinContent(xbin); x0 = GetBinCenter(xbin); y1 = GetBinContent(xbin+1); x1 = GetBinCenter(xbin+1); } return y0 + (x-x0)*((y1-y0)/(x1-x0)); } } //______________________________________________________________________________ Double_t TH1::Interpolate(Double_t, Double_t) { //Not yet implemented Error("Interpolate","This function must be called with 1 argument for a TH1"); return 0; } //______________________________________________________________________________ Double_t TH1::Interpolate(Double_t, Double_t, Double_t) { //Not yet implemented Error("Interpolate","This function must be called with 1 argument for a TH1"); return 0; } //______________________________________________________________________________ Bool_t TH1::IsBinOverflow(Int_t bin) const { // Return true if the bin is overflow. Int_t binx, biny, binz; GetBinXYZ(bin, binx, biny, binz); if ( fDimension == 1 ) return binx >= GetNbinsX() + 1; else if ( fDimension == 2 ) return (binx >= GetNbinsX() + 1) || (biny >= GetNbinsY() + 1); else if ( fDimension == 3 ) return (binx >= GetNbinsX() + 1) || (biny >= GetNbinsY() + 1) || (binz >= GetNbinsZ() + 1); else return 0; } //______________________________________________________________________________ Bool_t TH1::IsBinUnderflow(Int_t bin) const { // Return true if the bin is overflow. Int_t binx, biny, binz; GetBinXYZ(bin, binx, biny, binz); if ( fDimension == 1 ) return (binx <= 0); else if ( fDimension == 2 ) return (binx <= 0 || biny <= 0); else if ( fDimension == 3 ) return (binx <= 0 || biny <= 0 || binz <= 0); else return 0; } //___________________________________________________________________________ void TH1::LabelsDeflate(Option_t *ax) { // Reduce the number of bins for the axis passed in the option to the number of bins having a label. // The method will remove only the extra bins existing after the last "labeled" bin. // Note that if there are "un-labeled" bins present between "labeled" bins they will not be removed Int_t iaxis = AxisChoice(ax); TAxis *axis = 0; if (iaxis == 1) axis = GetXaxis(); if (iaxis == 2) axis = GetYaxis(); if (iaxis == 3) axis = GetZaxis(); if (!axis) { Error("LabelsDeflate","Invalid axis option %s",ax); return; } if (!axis->GetLabels()) return; // find bin with last labels // bin number is object ID in list of labels // therefore max bin number is number of bins of the deflated histograms TIter next(axis->GetLabels()); TObject *obj; Int_t nbins = 0; while ((obj = next())) { Int_t ibin = obj->GetUniqueID(); if (ibin > nbins) nbins = ibin; } if (nbins < 1) nbins = 1; TH1 *hold = (TH1*)IsA()->New(); R__ASSERT(hold); hold->SetDirectory(0); Copy(*hold); Bool_t timedisp = axis->GetTimeDisplay(); Double_t xmin = axis->GetXmin(); Double_t xmax = axis->GetBinUpEdge(nbins); if (xmax <= xmin) xmax = xmin +nbins; axis->SetRange(0,0); axis->Set(nbins,xmin,xmax); SetBinsLength(-1); // reset the number of cells Int_t errors = fSumw2.fN; if (errors) fSumw2.Set(fNcells); axis->SetTimeDisplay(timedisp); // reset histogram content Reset("ICE"); //now loop on all bins and refill // NOTE that if the bins without labels have content // it will be put in the underflow/overflow. // For this reason we use AddBinContent method Double_t oldEntries = fEntries; Int_t bin,binx,biny,binz; for (bin=0; bin < hold->fNcells; ++bin) { hold->GetBinXYZ(bin,binx,biny,binz); Int_t ibin = GetBin(binx,biny,binz); Double_t cu = hold->GetBinContent(bin); AddBinContent(ibin,cu); if (errors) { fSumw2.fArray[ibin] += hold->fSumw2.fArray[bin]; } } fEntries = oldEntries; delete hold; } //______________________________________________________________________________ void TH1::LabelsInflate(Option_t *ax) { // Double the number of bins for axis. // Refill histogram // This function is called by TAxis::FindBin(const char *label) Int_t iaxis = AxisChoice(ax); TAxis *axis = 0; if (iaxis == 1) axis = GetXaxis(); if (iaxis == 2) axis = GetYaxis(); if (iaxis == 3) axis = GetZaxis(); if (!axis) return; TH1 *hold = (TH1*)IsA()->New();; hold->SetDirectory(0); Copy(*hold); Bool_t timedisp = axis->GetTimeDisplay(); Int_t nbxold = fXaxis.GetNbins(); Int_t nbyold = fYaxis.GetNbins(); Int_t nbzold = fZaxis.GetNbins(); Int_t nbins = axis->GetNbins(); Double_t xmin = axis->GetXmin(); Double_t xmax = axis->GetXmax(); xmax = xmin + 2*(xmax-xmin); axis->SetRange(0,0); // double the bins and recompute ncells axis->Set(2*nbins,xmin,xmax); SetBinsLength(-1); Int_t errors = fSumw2.fN; if (errors) fSumw2.Set(fNcells); axis->SetTimeDisplay(timedisp); Reset("ICE"); // reset content and error //now loop on all bins and refill Double_t oldEntries = fEntries; Int_t bin,ibin,binx,biny,binz; for (ibin =0; ibin < fNcells; ibin++) { GetBinXYZ(ibin,binx,biny,binz); bin = hold->GetBin(binx,biny,binz); // NOTE that overflow in hold will be not considered if (binx > nbxold || biny > nbyold || binz > nbzold) bin = -1; if (bin > 0) { Double_t cu = hold->GetBinContent(bin); AddBinContent(ibin,cu); if (errors) fSumw2.fArray[ibin] += hold->fSumw2.fArray[bin]; } } fEntries = oldEntries; delete hold; } //______________________________________________________________________________ void TH1::LabelsOption(Option_t *option, Option_t *ax) { // Set option(s) to draw axis with labels // option = "a" sort by alphabetic order // = ">" sort by decreasing values // = "<" sort by increasing values // = "h" draw labels horizontal // = "v" draw labels vertical // = "u" draw labels up (end of label right adjusted) // = "d" draw labels down (start of label left adjusted) Int_t iaxis = AxisChoice(ax); TAxis *axis = 0; if (iaxis == 1) axis = GetXaxis(); if (iaxis == 2) axis = GetYaxis(); if (iaxis == 3) axis = GetZaxis(); if (!axis) return; THashList *labels = axis->GetLabels(); if (!labels) { Warning("LabelsOption","Cannot sort. No labels"); return; } TString opt = option; opt.ToLower(); if (opt.Contains("h")) { axis->SetBit(TAxis::kLabelsHori); axis->ResetBit(TAxis::kLabelsVert); axis->ResetBit(TAxis::kLabelsDown); axis->ResetBit(TAxis::kLabelsUp); } if (opt.Contains("v")) { axis->SetBit(TAxis::kLabelsVert); axis->ResetBit(TAxis::kLabelsHori); axis->ResetBit(TAxis::kLabelsDown); axis->ResetBit(TAxis::kLabelsUp); } if (opt.Contains("u")) { axis->SetBit(TAxis::kLabelsUp); axis->ResetBit(TAxis::kLabelsVert); axis->ResetBit(TAxis::kLabelsDown); axis->ResetBit(TAxis::kLabelsHori); } if (opt.Contains("d")) { axis->SetBit(TAxis::kLabelsDown); axis->ResetBit(TAxis::kLabelsVert); axis->ResetBit(TAxis::kLabelsHori); axis->ResetBit(TAxis::kLabelsUp); } Int_t sort = -1; if (opt.Contains("a")) sort = 0; if (opt.Contains(">")) sort = 1; if (opt.Contains("<")) sort = 2; if (sort < 0) return; if (sort > 0 && GetDimension() > 2) { Error("LabelsOption","Sorting by value not implemented for 3-D histograms"); return; } Double_t entries = fEntries; Int_t n = TMath::Min(axis->GetNbins(), labels->GetSize()); Int_t *a = new Int_t[n+2]; Int_t i,j,k; Double_t *cont = 0; Double_t *errors = 0; THashList *labold = new THashList(labels->GetSize(),1); TIter nextold(labels); TObject *obj; while ((obj=nextold())) { labold->Add(obj); } labels->Clear(); if (sort > 0) { //---sort by values of bins if (GetDimension() == 1) { cont = new Double_t[n]; if (fSumw2.fN) errors = new Double_t[n]; for (i=1;i<=n;i++) { cont[i-1] = GetBinContent(i); if (errors) errors[i-1] = GetBinError(i); } if (sort ==1) TMath::Sort(n,cont,a,kTRUE); //sort by decreasing values else TMath::Sort(n,cont,a,kFALSE); //sort by increasing values for (i=1;i<=n;i++) { SetBinContent(i,cont[a[i-1]]); if (errors) SetBinError(i,errors[a[i-1]]); } for (i=1;i<=n;i++) { obj = labold->At(a[i-1]); labels->Add(obj); obj->SetUniqueID(i); } } else if (GetDimension()== 2) { Double_t *pcont = new Double_t[n+2]; for (i=0;i<=n;i++) pcont[i] = 0; Int_t nx = fXaxis.GetNbins(); Int_t ny = fYaxis.GetNbins(); cont = new Double_t[(nx+2)*(ny+2)]; if (fSumw2.fN) errors = new Double_t[(nx+2)*(ny+2)]; for (i=1;i<=nx;i++) { for (j=1;j<=ny;j++) { cont[i+nx*j] = GetBinContent(i,j); if (errors) errors[i+nx*j] = GetBinError(i,j); if (axis == GetXaxis()) k = i; else k = j; pcont[k-1] += cont[i+nx*j]; } } if (sort ==1) TMath::Sort(n,pcont,a,kTRUE); //sort by decreasing values else TMath::Sort(n,pcont,a,kFALSE); //sort by increasing values for (i=0;i<n;i++) { obj = labold->At(a[i]); labels->Add(obj); obj->SetUniqueID(i+1); } delete [] pcont; if (axis == GetXaxis()) { for (i=1;i<=n;i++) { for (j=1;j<=ny;j++) { SetBinContent(i,j,cont[a[i-1]+1+nx*j]); if (errors) SetBinError(i,j,errors[a[i-1]+1+nx*j]); } } } else { // using y axis for (i=1;i<=nx;i++) { for (j=1;j<=n;j++) { SetBinContent(i,j,cont[i+nx*(a[j-1]+1)]); if (errors) SetBinError(i,j,errors[i+nx*(a[j-1]+1)]); } } } } else { //to be implemented for 3d } } else { //---alphabetic sort const UInt_t kUsed = 1<<18; TObject *objk=0; a[0] = 0; a[n+1] = n+1; for (i=1;i<=n;i++) { const char *label = "zzzzzzzzzzzz"; for (j=1;j<=n;j++) { obj = labold->At(j-1); if (!obj) continue; if (obj->TestBit(kUsed)) continue; //use strcasecmp for case non-sensitive sort (may be an option) if (strcmp(label,obj->GetName()) < 0) continue; objk = obj; a[i] = j; label = obj->GetName(); } if (objk) { objk->SetUniqueID(i); labels->Add(objk); objk->SetBit(kUsed); } } for (i=1;i<=n;i++) { obj = labels->At(i-1); if (!obj) continue; obj->ResetBit(kUsed); } if (GetDimension() == 1) { cont = new Double_t[n+2]; if (fSumw2.fN) errors = new Double_t[n+2]; for (i=1;i<=n;i++) { cont[i] = GetBinContent(a[i]); if (errors) errors[i] = GetBinError(a[i]); } for (i=1;i<=n;i++) { SetBinContent(i,cont[i]); if (errors) SetBinError(i,errors[i]); } } else if (GetDimension()== 2) { Int_t nx = fXaxis.GetNbins()+2; Int_t ny = fYaxis.GetNbins()+2; cont = new Double_t[nx*ny]; if (fSumw2.fN) errors = new Double_t[nx*ny]; for (i=0;i<nx;i++) { for (j=0;j<ny;j++) { cont[i+nx*j] = GetBinContent(i,j); if (errors) errors[i+nx*j] = GetBinError(i,j); } } if (axis == GetXaxis()) { for (i=1;i<=n;i++) { for (j=0;j<ny;j++) { SetBinContent(i,j,cont[a[i]+nx*j]); if (errors) SetBinError(i,j,errors[a[i]+nx*j]); } } } else { for (i=0;i<nx;i++) { for (j=1;j<=n;j++) { SetBinContent(i,j,cont[i+nx*a[j]]); if (errors) SetBinError(i,j,errors[i+nx*a[j]]); } } } } else { Int_t nx = fXaxis.GetNbins()+2; Int_t ny = fYaxis.GetNbins()+2; Int_t nz = fZaxis.GetNbins()+2; cont = new Double_t[nx*ny*nz]; if (fSumw2.fN) errors = new Double_t[nx*ny*nz]; for (i=0;i<nx;i++) { for (j=0;j<ny;j++) { for (k=0;k<nz;k++) { cont[i+nx*(j+ny*k)] = GetBinContent(i,j,k); if (errors) errors[i+nx*(j+ny*k)] = GetBinError(i,j,k); } } } if (axis == GetXaxis()) { // labels on x axis for (i=1;i<=n;i++) { for (j=0;j<ny;j++) { for (k=0;k<nz;k++) { SetBinContent(i,j,k,cont[a[i]+nx*(j+ny*k)]); if (errors) SetBinError(i,j,k,errors[a[i]+nx*(j+ny*k)]); } } } } else if (axis == GetYaxis()) { // labels on y axis for (i=0;i<nx;i++) { for (j=1;j<=n;j++) { for (k=0;k<nz;k++) { SetBinContent(i,j,k,cont[i+nx*(a[j]+ny*k)]); if (errors) SetBinError(i,j,k,errors[i+nx*(a[j]+ny*k)]); } } } } else { // labels on z axis for (i=0;i<nx;i++) { for (j=0;j<ny;j++) { for (k=1;k<=n;k++) { SetBinContent(i,j,k,cont[i+nx*(j+ny*a[k])]); if (errors) SetBinError(i,j,k,errors[i+nx*(j+ny*a[k])]); } } } } } } fEntries = entries; delete labold; if (a) delete [] a; if (cont) delete [] cont; if (errors) delete [] errors; } //______________________________________________________________________________ static inline Bool_t AlmostEqual(Double_t a, Double_t b, Double_t epsilon = 0.00000001) { return TMath::Abs(a - b) < epsilon; } //______________________________________________________________________________ static inline Bool_t AlmostInteger(Double_t a, Double_t epsilon = 0.00000001) { return AlmostEqual(a - TMath::Floor(a), 0, epsilon) || AlmostEqual(a - TMath::Floor(a), 1, epsilon); } //______________________________________________________________________________ Bool_t TH1::SameLimitsAndNBins(const TAxis& axis1, const TAxis& axis2) { // Same limits and bins. if ((axis1.GetNbins() == axis2.GetNbins()) && (axis1.GetXmin() == axis2.GetXmin()) && (axis1.GetXmax() == axis2.GetXmax())) return kTRUE; else return kFALSE; } static inline bool IsEquidistantBinning(const TAxis& axis) { // check if axis bin are equals if (!axis.GetXbins()->fN) return true; // // not able to check if there is only one axis entry bool isEquidistant = true; const Double_t firstBinWidth = axis.GetBinWidth(1); for (int i = 1; i < axis.GetNbins(); ++i) { const Double_t binWidth = axis.GetBinWidth(i); const bool match = TMath::AreEqualRel(firstBinWidth, binWidth, TMath::Limits<Double_t>::Epsilon()); isEquidistant &= match; if (!match) break; } return isEquidistant; } //______________________________________________________________________________ Bool_t TH1::RecomputeAxisLimits(TAxis& destAxis, const TAxis& anAxis) { // Finds new limits for the axis for the Merge function. // returns false if the limits are incompatible if (SameLimitsAndNBins(destAxis, anAxis)) return kTRUE; if (!IsEquidistantBinning(destAxis) || !IsEquidistantBinning(anAxis)) return kFALSE; // not equidistant user binning not supported Double_t width1 = destAxis.GetBinWidth(0); Double_t width2 = anAxis.GetBinWidth(0); if (width1 == 0 || width2 == 0) return kFALSE; // no binning not supported Double_t xmin = TMath::Min(destAxis.GetXmin(), anAxis.GetXmin()); Double_t xmax = TMath::Max(destAxis.GetXmax(), anAxis.GetXmax()); Double_t width = TMath::Max(width1, width2); // check the bin size if (!AlmostInteger(width/width1) || !AlmostInteger(width/width2)) return kFALSE; // std::cout << "Find new limit using given axis " << anAxis.GetXmin() << " , " << anAxis.GetXmax() << " bin width " << width2 << std::endl; // std::cout << " and destination axis " << destAxis.GetXmin() << " , " << destAxis.GetXmax() << " bin width " << width1 << std::endl; // check the limits Double_t delta; delta = (destAxis.GetXmin() - xmin)/width1; if (!AlmostInteger(delta)) xmin -= (TMath::Ceil(delta) - delta)*width1; delta = (anAxis.GetXmin() - xmin)/width2; if (!AlmostInteger(delta)) xmin -= (TMath::Ceil(delta) - delta)*width2; delta = (destAxis.GetXmin() - xmin)/width1; if (!AlmostInteger(delta)) return kFALSE; delta = (xmax - destAxis.GetXmax())/width1; if (!AlmostInteger(delta)) xmax += (TMath::Ceil(delta) - delta)*width1; delta = (xmax - anAxis.GetXmax())/width2; if (!AlmostInteger(delta)) xmax += (TMath::Ceil(delta) - delta)*width2; delta = (xmax - destAxis.GetXmax())/width1; if (!AlmostInteger(delta)) return kFALSE; #ifdef DEBUG if (!AlmostInteger((xmax - xmin) / width)) { // unnecessary check printf("TH1::RecomputeAxisLimits - Impossible\n"); return kFALSE; } #endif destAxis.Set(TMath::Nint((xmax - xmin)/width), xmin, xmax); //std::cout << "New re-computed axis : [ " << xmin << " , " << xmax << " ] width = " << width << " nbins " << destAxis.GetNbins() << std::endl; return kTRUE; } //______________________________________________________________________________ Long64_t TH1::Merge(TCollection *li) { // Add all histograms in the collection to this histogram. // This function computes the min/max for the x axis, // compute a new number of bins, if necessary, // add bin contents, errors and statistics. // If all histograms have bin labels, bins with identical labels // will be merged, no matter what their order is. // If overflows are present and limits are different the function will fail. // The function returns the total number of entries in the result histogram // if the merge is successful, -1 otherwise. // // IMPORTANT remark. The axis x may have different number // of bins and different limits, BUT the largest bin width must be // a multiple of the smallest bin width and the upper limit must also // be a multiple of the bin width. // Example: // void atest() { // TH1F *h1 = new TH1F("h1","h1",110,-110,0); // TH1F *h2 = new TH1F("h2","h2",220,0,110); // TH1F *h3 = new TH1F("h3","h3",330,-55,55); // TRandom r; // for (Int_t i=0;i<10000;i++) { // h1->Fill(r.Gaus(-55,10)); // h2->Fill(r.Gaus(55,10)); // h3->Fill(r.Gaus(0,10)); // } // // TList *list = new TList; // list->Add(h1); // list->Add(h2); // list->Add(h3); // TH1F *h = (TH1F*)h1->Clone("h"); // h->Reset(); // h->Merge(list); // h->Draw(); // } if (!li) return 0; if (li->IsEmpty()) return (Long64_t) GetEntries(); // is this really needed ? TList inlist; inlist.AddAll(li); TAxis newXAxis; Bool_t initialLimitsFound = kFALSE; Bool_t allHaveLabels = kTRUE; // assume all histo have labels and check later Bool_t allHaveLimits = kTRUE; Bool_t allSameLimits = kTRUE; Bool_t foundLabelHist = kFALSE; //Bool_t firstHistWithLimits = kTRUE; TIter next(&inlist); // start looping with this histogram TH1 * h = this; do { // do not skip anymore empty histograms // since are used to set the limits Bool_t hasLimits = h->GetXaxis()->GetXmin() < h->GetXaxis()->GetXmax(); allHaveLimits = allHaveLimits && hasLimits; if (hasLimits) { h->BufferEmpty(); // this is done in case the first histograms are empty and // the histogram have different limits #ifdef LATER if (firstHistWithLimits ) { // set axis limits in the case the first histogram did not have limits if (h != this && !SameLimitsAndNBins( fXaxis, *h->GetXaxis()) ) { if (h->GetXaxis()->GetXbins()->GetSize() != 0) fXaxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXbins()->GetArray()); else fXaxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax()); } firstHistWithLimits = kFALSE; } #endif // this is executed the first time an histogram with limits is found // to set some initial values on the new axis if (!initialLimitsFound) { initialLimitsFound = kTRUE; if (h->GetXaxis()->GetXbins()->GetSize() != 0) newXAxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXbins()->GetArray()); else newXAxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax()); } else { // check first if histograms have same bins if (!SameLimitsAndNBins(newXAxis, *(h->GetXaxis())) ) { allSameLimits = kFALSE; // recompute the limits in this case the optimal limits // The condition to works is that the histogram have same bin with // and one common bin edge if (!RecomputeAxisLimits(newXAxis, *(h->GetXaxis()))) { Error("Merge", "Cannot merge histograms - limits are inconsistent:\n " "first: (%d, %f, %f), second: (%d, %f, %f)", newXAxis.GetNbins(), newXAxis.GetXmin(), newXAxis.GetXmax(), h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax()); return -1; } } } } if (allHaveLabels) { THashList* hlabels=h->GetXaxis()->GetLabels(); Bool_t haveOneLabel = (hlabels != 0); // do here to print message only one time if (foundLabelHist && allHaveLabels && !haveOneLabel) { Warning("Merge","Not all histograms have labels. I will ignore labels," " falling back to bin numbering mode."); } allHaveLabels &= (haveOneLabel); // for the error message if (haveOneLabel) foundLabelHist = kTRUE; // I could add a check if histogram contains bins without a label // and with non-zero bin content // Do we want to support this ??? // only in case the kCanRebin bit is not set if (allHaveLabels && !h->TestBit(TH1::kCanRebin) ) { // count number of bins with non-null content Int_t non_zero_bins = 0; Int_t nbins = h->GetXaxis()->GetNbins(); if (nbins > hlabels->GetEntries() ) { for (Int_t i = 1; i <= nbins; i++) { if (h->GetBinContent(i) != 0 || (fSumw2.fN && h->GetBinError(i) != 0) ) { non_zero_bins++; } } if (non_zero_bins > hlabels->GetEntries() ) { Warning("Merge","Histogram %s contains non-empty bins without labels - falling back to bin numbering mode",h->GetName() ); allHaveLabels = kFALSE; } } } } } while ( ( h = dynamic_cast<TH1*> ( next() ) ) != NULL ); if (!h && (*next) ) { Error("Merge","Attempt to merge object of class: %s to a %s", (*next)->ClassName(),this->ClassName()); return -1; } next.Reset(); // In the case of histogram with different limits // newXAxis will now have the new found limits // but one needs first to clone this histogram to perform the merge // The clone is not needed when all histograms have the same limits TH1 * hclone = 0; if (!allSameLimits) { // We don't want to add the clone to gDirectory, // so remove our kMustCleanup bit temporarily Bool_t mustCleanup = TestBit(kMustCleanup); if (mustCleanup) ResetBit(kMustCleanup); hclone = (TH1*)IsA()->New(); hclone->SetDirectory(0); Copy(*hclone); if (mustCleanup) SetBit(kMustCleanup); BufferEmpty(1); // To remove buffer. Reset(); // BufferEmpty sets limits so we can't use it later. SetEntries(0); inlist.AddFirst(hclone); } // set the binning and cell content on the histogram to merge when the histograms do not have the same binning // and when one of the histogram does not have limits if (initialLimitsFound && (!allSameLimits || !allHaveLimits )) { if (newXAxis.GetXbins()->GetSize() != 0) SetBins(newXAxis.GetNbins(), newXAxis.GetXbins()->GetArray()); else SetBins(newXAxis.GetNbins(), newXAxis.GetXmin(), newXAxis.GetXmax()); } // std::cout << "Merging on histogram " << GetName() << std::endl; // std::cout << "Merging flags : allHaveLimits - allHaveLabels - initialLimitsFound - allSameLimits " << std::endl; // std::cout << " " << allHaveLimits << "\t\t" << allHaveLabels << "\t\t" << initialLimitsFound << "\t\t" << allSameLimits << std::endl; if (!allHaveLimits && !allHaveLabels) { // fill this histogram with all the data from buffers of histograms without limits while (TH1* hist = (TH1*)next()) { // support also case where some histogram have limits and some have the buffer if ( (hist->GetXaxis()->GetXmin() >= hist->GetXaxis()->GetXmax() ) && hist->fBuffer ) { // no limits Int_t nbentries = (Int_t)hist->fBuffer[0]; for (Int_t i = 0; i < nbentries; i++) Fill(hist->fBuffer[2*i + 2], hist->fBuffer[2*i + 1]); // Entries from buffers have to be filled one by one // because FillN doesn't resize histograms. } } // all histograms have been processed if (!initialLimitsFound ) { // here the case where all histograms don't have limits // In principle I should not have copied in hclone since // when initialLimitsFound = false then allSameLimits should be true if (hclone) { inlist.Remove(hclone); delete hclone; } return (Long64_t) GetEntries(); } // In case some of the histograms do not have limits // I need to remove the buffer if (fBuffer) BufferEmpty(1); next.Reset(); } //merge bin contents and errors // in case when histogram have limits Double_t stats[kNstat], totstats[kNstat]; for (Int_t i=0;i<kNstat;i++) {totstats[i] = stats[i] = 0;} GetStats(totstats); Double_t nentries = GetEntries(); Bool_t canRebin=TestBit(kCanRebin); // reset, otherwise setting the under/overflow will rebin and make a mess if (!allHaveLabels) ResetBit(kCanRebin); while (TH1* hist=(TH1*)next()) { // process only if the histogram has limits; otherwise it was processed before // in the case of an existing buffer (see if statement just before) //std::cout << "merging histogram " << GetName() << " with " << hist->GetName() << std::endl; // skip empty histograms Double_t histEntries = hist->GetEntries(); if (hist->fTsumw == 0 && histEntries == 0) continue; // merge for labels or histogram with limits if (allHaveLabels || (hist->GetXaxis()->GetXmin() < hist->GetXaxis()->GetXmax()) ) { // import statistics hist->GetStats(stats); for (Int_t i=0;i<kNstat;i++) totstats[i] += stats[i]; nentries += histEntries; Int_t nx = hist->GetXaxis()->GetNbins(); // loop on bins of the histogram and do the merge for (Int_t binx = 0; binx <= nx + 1; binx++) { Double_t cu = hist->GetBinContent(binx); Double_t error1 = 0; Int_t ix = -1; if (fSumw2.fN) error1= hist->GetBinError(binx); // do only for bins with non null bin content or non-null errors (if Sumw2) if (TMath::Abs(cu) > 0 || (fSumw2.fN && error1 > 0 ) ) { // case of overflow bins // they do not make sense also in the case of labels if (!allHaveLabels) { // case of bins without labels if (!allSameLimits) { if ( binx==0 || binx== nx+1) { Error("Merge", "Cannot merge histograms - the histograms have" " different limits and undeflows/overflows are present." " The initial histogram is now broken!"); return -1; } // NOTE: in the case of one of the histogram as labels - it is treated as // an error and it has been flagged before // since calling FindBin(x) for histo with labels does not make sense // and the result is unpredictable ix = fXaxis.FindBin(hist->GetXaxis()->GetBinCenter(binx)); } else { // histogram have same limits - no need to call FindBin ix = binx; } } else { // here only in the case of bins with labels const char* label=hist->GetXaxis()->GetBinLabel(binx); // do we need to support case when there are bins with labels and bins without them ?? // NO -then return an error if (label == 0 ) { Fatal("Merge","Histogram %s with labels has NULL label pointer for bin %d", hist->GetName(),binx ); return -1; } if (label[0] == 0 ) { // case label is "" , i.e. is not set // exclude underflow which could contain the non-existing labels // thsi we could merge in all underflow if ( binx > 0 && binx <= nx) { Error("Merge","Cannot merge ! Label histogram %s contains a bin %d which has not a label and has non-zero content ",hist->GetName(),binx ); return -1; } else // case of underflow/overflow ix = binx; } else { // if bin does not exists FindBin will add it automatically // by calling LabelsInflate() if the bit is set // otherwise it will return zero and bin will be merged in underflow/overflow // Do we want to keep this case ?? ix = fXaxis.FindBin(label); } // ix cannot be -1 . Can be 0 in case label is not found and bit is not set if (ix <0) { Fatal("Merge","Error return from TAxis::FindBin for label %s",label); return -1; } } if (ix >= 0) { // MERGE here the bin contents //std::cout << "merging bin " << binx << " into " << ix << " with bin content " << cu << " bin center x = " << GetBinCenter(ix) << std::endl; if (ix > fNcells ) Fatal("Merge","Fatal error merging histogram %s - bin number is %d and array size is %d",GetName(), ix,fNcells); AddBinContent(ix,cu); if (fSumw2.fN) fSumw2.fArray[ix] += error1*error1; } } } } } if (canRebin) SetBit(kCanRebin); //copy merged stats PutStats(totstats); SetEntries(nentries); if (hclone) { inlist.Remove(hclone); delete hclone; } return (Long64_t)nentries; } //______________________________________________________________________________ Bool_t TH1::Multiply(TF1 *f1, Double_t c1) { // Performs the operation: this = this*c1*f1 // if errors are defined (see TH1::Sumw2), errors are also recalculated. // // Only bins inside the function range are recomputed. // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Multiply // // The function return kFALSE if the Multiply operation failed if (!f1) { Error("Add","Attempt to multiply by a non-existing function"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // reset min-maximum SetMinimum(); SetMaximum(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t cu,w; Double_t xx[3]; Double_t *params = 0; f1->InitArgs(xx,params); for (binz=0;binz<=nbinsz+1;binz++) { xx[2] = fZaxis.GetBinCenter(binz); for (biny=0;biny<=nbinsy+1;biny++) { xx[1] = fYaxis.GetBinCenter(biny); for (binx=0;binx<=nbinsx+1;binx++) { xx[0] = fXaxis.GetBinCenter(binx); if (!f1->IsInside(xx)) continue; TF1::RejectPoint(kFALSE); bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); Double_t error1 = GetBinError(bin); cu = c1*f1->EvalPar(xx); if (TF1::RejectedPoint()) continue; w = GetBinContent(bin)*cu; SetBinContent(bin,w); if (fSumw2.fN) { fSumw2.fArray[bin] = cu*cu*error1*error1; } } } } ResetStats(); return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Multiply(const TH1 *h1) { // -*-*-*-*-*-*-*-*-*Multiply this histogram by h1*-*-*-*-*-*-*-*-*-*-*-*-* // ============================= // // this = this*h1 // // If errors of this are available (TH1::Sumw2), errors are recalculated. // Note that if h1 has Sumw2 set, Sumw2 is automatically called for this // if not already set. // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Multiply // // The function return kFALSE if the Multiply operation failed if (!h1) { Error("Multiply","Attempt to multiply by a non-existing histogram"); return kFALSE; } Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); try { CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Multiply","Attempt to multiply histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Multiply","Attempt to multiply histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Multiply","Attempt to multiply histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Multiply","Attempt to multiply histograms with different labels"); } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 has Sumw2 set if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2(); // - Reset min- maximum SetMinimum(); SetMaximum(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t c0,c1,w; for (binz=0;binz<=nbinsz+1;binz++) { for (biny=0;biny<=nbinsy+1;biny++) { for (binx=0;binx<=nbinsx+1;binx++) { bin = GetBin(binx,biny,binz); c0 = GetBinContent(bin); c1 = h1->GetBinContent(bin); w = c0*c1; SetBinContent(bin,w); if (fSumw2.fN) { Double_t e0 = GetBinError(bin); Double_t e1 = h1->GetBinError(bin); fSumw2.fArray[bin] = (e0*e0*c1*c1 + e1*e1*c0*c0); } } } } ResetStats(); return kTRUE; } //______________________________________________________________________________ Bool_t TH1::Multiply(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t *option) { // -*-*-*Replace contents of this histogram by multiplication of h1 by h2*-* // ================================================================ // // this = (c1*h1)*(c2*h2) // // If errors of this are available (TH1::Sumw2), errors are recalculated. // Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this // if not already set. // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Multiply // // The function return kFALSE if the Multiply operation failed TString opt = option; opt.ToLower(); // Bool_t binomial = kFALSE; // if (opt.Contains("b")) binomial = kTRUE; if (!h1 || !h2) { Error("Multiply","Attempt to multiply by a non-existing histogram"); return kFALSE; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t nbinsx = GetNbinsX(); Int_t nbinsy = GetNbinsY(); Int_t nbinsz = GetNbinsZ(); try { CheckConsistency(h1,h2); CheckConsistency(this,h1); } catch(DifferentNumberOfBins&) { Error("Multiply","Attempt to multiply histograms with different number of bins"); return kFALSE; } catch(DifferentAxisLimits&) { Warning("Multiply","Attempt to multiply histograms with different axis limits"); } catch(DifferentBinLimits&) { Warning("Multiply","Attempt to multiply histograms with different bin limits"); } catch(DifferentLabels&) { Warning("Multiply","Attempt to multiply histograms with different labels"); } if (fDimension < 2) nbinsy = -1; if (fDimension < 3) nbinsz = -1; // Create Sumw2 if h1 or h2 have Sumw2 set if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2(); // - Reset min - maximum SetMinimum(); SetMaximum(); // Reset the kCanRebin option. Otherwise SetBinContent on the overflow bin // would resize the axis limits! ResetBit(kCanRebin); // - Loop on bins (including underflows/overflows) Int_t bin, binx, biny, binz; Double_t b1,b2,w,d1,d2; d1 = c1*c1; d2 = c2*c2; for (binz=0;binz<=nbinsz+1;binz++) { for (biny=0;biny<=nbinsy+1;biny++) { for (binx=0;binx<=nbinsx+1;binx++) { bin = binx +(nbinsx+2)*(biny + (nbinsy+2)*binz); b1 = h1->GetBinContent(bin); b2 = h2->GetBinContent(bin); w = (c1*b1)*(c2*b2); SetBinContent(bin,w); if (fSumw2.fN) { Double_t e1 = h1->GetBinError(bin); Double_t e2 = h2->GetBinError(bin); fSumw2.fArray[bin] = d1*d2*(e1*e1*b2*b2 + e2*e2*b1*b1); } } } } ResetStats(); return kTRUE; } //______________________________________________________________________________ void TH1::Paint(Option_t *option) { // -*-*-*-*-*-*-*Control routine to paint any kind of histograms*-*-*-*-*-*-* // =============================================== // // This function is automatically called by TCanvas::Update. // (see TH1::Draw for the list of options) GetPainter(option); if (fPainter) { if (strlen(option) > 0) fPainter->Paint(option); else fPainter->Paint(fOption.Data()); } } //______________________________________________________________________________ TH1 *TH1::Rebin(Int_t ngroup, const char*newname, const Double_t *xbins) { // Rebin this histogram // // -case 1 xbins=0 // If newname is blank (default), the current histogram is modified and // a pointer to it is returned. // // If newname is not blank, the current histogram is not modified, and a // new histogram is returned which is a Clone of the current histogram // with its name set to newname. // // The parameter ngroup indicates how many bins of this have to be merged // into one bin of the result. // // If the original histogram has errors stored (via Sumw2), the resulting // histograms has new errors correctly calculated. // // examples: if h1 is an existing TH1F histogram with 100 bins // h1->Rebin(); //merges two bins in one in h1: previous contents of h1 are lost // h1->Rebin(5); //merges five bins in one in h1 // TH1F *hnew = h1->Rebin(5,"hnew"); // creates a new histogram hnew // // merging 5 bins of h1 in one bin // // NOTE: If ngroup is not an exact divider of the number of bins, // the top limit of the rebinned histogram is reduced // to the upper edge of the last bin that can make a complete // group. The remaining bins are added to the overflow bin. // Statistics will be recomputed from the new bin contents. // // -case 2 xbins!=0 // A new histogram is created (you should specify newname). // The parameter ngroup is the number of variable size bins in the created histogram. // The array xbins must contain ngroup+1 elements that represent the low-edges // of the bins. // If the original histogram has errors stored (via Sumw2), the resulting // histograms has new errors correctly calculated. // // NOTE: The bin edges specified in xbins should correspond to bin edges // in the original histogram. If a bin edge in the new histogram is // in the middle of a bin in the original histogram, all entries in // the split bin in the original histogram will be transfered to the // lower of the two possible bins in the new histogram. This is // probably not what you want. // // examples: if h1 is an existing TH1F histogram with 100 bins // Double_t xbins[25] = {...} array of low-edges (xbins[25] is the upper edge of last bin // h1->Rebin(24,"hnew",xbins); //creates a new variable bin size histogram hnew Int_t nbins = fXaxis.GetNbins(); Double_t xmin = fXaxis.GetXmin(); Double_t xmax = fXaxis.GetXmax(); if ((ngroup <= 0) || (ngroup > nbins)) { Error("Rebin", "Illegal value of ngroup=%d",ngroup); return 0; } if (fDimension > 1 || InheritsFrom(TProfile::Class())) { Error("Rebin", "Operation valid on 1-D histograms only"); return 0; } if (!newname && xbins) { Error("Rebin","if xbins is specified, newname must be given"); return 0; } Int_t newbins = nbins/ngroup; if (!xbins) { Int_t nbg = nbins/ngroup; if (nbg*ngroup != nbins) { Warning("Rebin", "ngroup=%d is not an exact divider of nbins=%d.",ngroup,nbins); } } else { // in the case that xbins is given (rebinning in variable bins), ngroup is // the new number of bins and number of grouped bins is not constant. // when looping for setting the contents for the new histogram we // need to loop on all bins of original histogram. Then set ngroup=nbins newbins = ngroup; ngroup = nbins; } // Save old bin contents into a new array Double_t entries = fEntries; Double_t *oldBins = new Double_t[nbins+2]; Int_t bin, i; for (bin=0;bin<nbins+2;bin++) oldBins[bin] = GetBinContent(bin); Double_t *oldErrors = 0; if (fSumw2.fN != 0) { oldErrors = new Double_t[nbins+2]; for (bin=0;bin<nbins+2;bin++) oldErrors[bin] = GetBinError(bin); } // rebin will not include underflow/overflow if new axis range is larger than old axis range if (xbins) { if (xbins[0] < fXaxis.GetXmin() && oldBins[0] != 0 ) Warning("Rebin","underflow entries will not be used when rebinning"); if (xbins[newbins] > fXaxis.GetXmax() && oldBins[nbins+1] != 0 ) Warning("Rebin","overflow entries will not be used when rebinning"); } // create a clone of the old histogram if newname is specified TH1 *hnew = this; if ((newname && strlen(newname) > 0) || xbins) { hnew = (TH1*)Clone(newname); } //reset kCanRebin bit to avoid a rebinning in SetBinContent Int_t bitRebin = hnew->TestBit(kCanRebin); hnew->SetBit(kCanRebin,0); // save original statistics Double_t stat[kNstat]; GetStats(stat); bool resetStat = false; // change axis specs and rebuild bin contents array::RebinAx if(!xbins && (newbins*ngroup != nbins)) { xmax = fXaxis.GetBinUpEdge(newbins*ngroup); resetStat = true; //stats must be reset because top bins will be moved to overflow bin } // save the TAttAxis members (reset by SetBins) Int_t nDivisions = fXaxis.GetNdivisions(); Color_t axisColor = fXaxis.GetAxisColor(); Color_t labelColor = fXaxis.GetLabelColor(); Style_t labelFont = fXaxis.GetLabelFont(); Float_t labelOffset = fXaxis.GetLabelOffset(); Float_t labelSize = fXaxis.GetLabelSize(); Float_t tickLength = fXaxis.GetTickLength(); Float_t titleOffset = fXaxis.GetTitleOffset(); Float_t titleSize = fXaxis.GetTitleSize(); Color_t titleColor = fXaxis.GetTitleColor(); Style_t titleFont = fXaxis.GetTitleFont(); if(!xbins && (fXaxis.GetXbins()->GetSize() > 0)){ // variable bin sizes Double_t *bins = new Double_t[newbins+1]; for(i = 0; i <= newbins; ++i) bins[i] = fXaxis.GetBinLowEdge(1+i*ngroup); hnew->SetBins(newbins,bins); //this also changes errors array (if any) delete [] bins; } else if (xbins) { hnew->SetBins(newbins,xbins); } else { hnew->SetBins(newbins,xmin,xmax); } // Restore axis attributes fXaxis.SetNdivisions(nDivisions); fXaxis.SetAxisColor(axisColor); fXaxis.SetLabelColor(labelColor); fXaxis.SetLabelFont(labelFont); fXaxis.SetLabelOffset(labelOffset); fXaxis.SetLabelSize(labelSize); fXaxis.SetTickLength(tickLength); fXaxis.SetTitleOffset(titleOffset); fXaxis.SetTitleSize(titleSize); fXaxis.SetTitleColor(titleColor); fXaxis.SetTitleFont(titleFont); // copy merged bin contents (ignore under/overflows) // Start merging only once the new lowest edge is reached Int_t startbin = 1; const Double_t newxmin = hnew->GetXaxis()->GetBinLowEdge(1); while( fXaxis.GetBinCenter(startbin) < newxmin && startbin <= nbins ) { startbin++; } Int_t oldbin = startbin; Double_t binContent, binError; for (bin = 1;bin<=newbins;bin++) { binContent = 0; binError = 0; Int_t imax = ngroup; Double_t xbinmax = hnew->GetXaxis()->GetBinUpEdge(bin); for (i=0;i<ngroup;i++) { if( (oldbin+i > nbins) || ( hnew != this && (fXaxis.GetBinCenter(oldbin+i) > xbinmax)) ) { imax = i; break; } binContent += oldBins[oldbin+i]; if (oldErrors) binError += oldErrors[oldbin+i]*oldErrors[oldbin+i]; } hnew->SetBinContent(bin,binContent); if (oldErrors) hnew->SetBinError(bin,TMath::Sqrt(binError)); oldbin += imax; } // sum underflow and overflow contents until startbin binContent = 0; binError = 0; for (i = 0; i < startbin; ++i) { binContent += oldBins[i]; if (oldErrors) binError += oldErrors[i]*oldErrors[i]; } hnew->SetBinContent(0,binContent); if (oldErrors) hnew->SetBinError(0,TMath::Sqrt(binError)); // sum overflow binContent = 0; binError = 0; for (i = oldbin; i <= nbins+1; ++i) { binContent += oldBins[i]; if (oldErrors) binError += oldErrors[i]*oldErrors[i]; } hnew->SetBinContent(newbins+1,binContent); if (oldErrors) hnew->SetBinError(newbins+1,TMath::Sqrt(binError)); hnew->SetBit(kCanRebin,bitRebin); // restore statistics and entries modified by SetBinContent hnew->SetEntries(entries); if (!resetStat) hnew->PutStats(stat); delete [] oldBins; if (oldErrors) delete [] oldErrors; return hnew; } //______________________________________________________________________________ Bool_t TH1::FindNewAxisLimits(const TAxis* axis, const Double_t point, Double_t& newMin, Double_t &newMax) { // finds new limits for the axis so that *point* is within the range and // the limits are compatible with the previous ones (see TH1::Merge). // new limits are put into *newMin* and *newMax* variables. // axis - axis whose limits are to be recomputed // point - point that should fit within the new axis limits // newMin - new minimum will be stored here // newMax - new maximum will be stored here. // false if failed (e.g. if the initial axis limits are wrong // or the new range is more than 2^64 times the old one). Double_t xmin = axis->GetXmin(); Double_t xmax = axis->GetXmax(); if (xmin >= xmax) return kFALSE; Double_t range = xmax-xmin; Double_t binsize = range / axis->GetNbins(); //recompute new axis limits by doubling the current range Int_t ntimes = 0; while (point < xmin) { if (ntimes++ > 64) return kFALSE; xmin = xmin - range; range *= 2; binsize *= 2; // // make sure that the merging will be correct // if ( xmin / binsize - TMath::Floor(xmin / binsize) >= 0.5) { // xmin += 0.5 * binsize; // xmax += 0.5 * binsize; // won't work with a histogram with only one bin, but I don't care // } } while (point >= xmax) { if (ntimes++ > 64) return kFALSE; xmax = xmax + range; range *= 2; binsize *= 2; // // make sure that the merging will be correct // if ( xmin / binsize - TMath::Floor(xmin / binsize) >= 0.5) { // xmin -= 0.5 * binsize; // xmax -= 0.5 * binsize; // won't work with a histogram with only one bin, but I don't care // } } newMin = xmin; newMax = xmax; // Info("FindNewAxisLimits", "OldAxis: (%lf, %lf), new: (%lf, %lf), point: %lf", // axis->GetXmin(), axis->GetXmax(), xmin, xmax, point); return kTRUE; } //______________________________________________________________________________ void TH1::RebinAxis(Double_t x, TAxis *axis) { // Histogram is resized along axis such that x is in the axis range. // The new axis limits are recomputed by doubling iteratively // the current axis range until the specified value x is within the limits. // The algorithm makes a copy of the histogram, then loops on all bins // of the old histogram to fill the rebinned histogram. // Takes into account errors (Sumw2) if any. // The algorithm works for 1-d, 2-D and 3-D histograms. // The bit kCanRebin must be set before invoking this function. // Ex: h->SetBit(TH1::kCanRebin); if (!TestBit(kCanRebin)) return; if (TMath::IsNaN(x)) { // x may be a NaN ResetBit(kCanRebin); return; } if (axis->GetXmin() >= axis->GetXmax()) return; if (axis->GetNbins() <= 0) return; Double_t xmin, xmax; if (!FindNewAxisLimits(axis, x, xmin, xmax)) return; //save a copy of this histogram TH1 *hold = (TH1*)IsA()->New(); hold->SetDirectory(0); Copy(*hold); //set new axis limits axis->SetLimits(xmin,xmax); Int_t nbinsx = fXaxis.GetNbins(); Int_t nbinsy = fYaxis.GetNbins(); Int_t nbinsz = fZaxis.GetNbins(); //now loop on all bins and refill Double_t err,cu; Double_t bx,by,bz; Int_t errors = GetSumw2N(); Int_t ix,iy,iz,ibin,binx,biny,binz,bin; Reset("ICE"); //reset only Integral, contents and Errors for (binz=1;binz<=nbinsz;binz++) { bz = hold->GetZaxis()->GetBinCenter(binz); iz = fZaxis.FindFixBin(bz); for (biny=1;biny<=nbinsy;biny++) { by = hold->GetYaxis()->GetBinCenter(biny); iy = fYaxis.FindFixBin(by); for (binx=1;binx<=nbinsx;binx++) { bx = hold->GetXaxis()->GetBinCenter(binx); ix = fXaxis.FindFixBin(bx); bin = hold->GetBin(binx,biny,binz); ibin= GetBin(ix,iy,iz); cu = hold->GetBinContent(bin); AddBinContent(ibin,cu); if (errors) { err = hold->GetBinError(bin); fSumw2.fArray[ibin] += err*err; } } } } delete hold; } //______________________________________________________________________________ void TH1::RecursiveRemove(TObject *obj) { // Recursively remove object from the list of functions if (fFunctions) { if (!fFunctions->TestBit(kInvalidObject)) fFunctions->RecursiveRemove(obj); } } //______________________________________________________________________________ void TH1::Scale(Double_t c1, Option_t *option) { // -*-*-*Multiply this histogram by a constant c1*-*-*-*-*-*-*-*-* // ======================================== // // this = c1*this // // Note that both contents and errors(if any) are scaled. // This function uses the services of TH1::Add // // IMPORTANT NOTE: If you intend to use the errors of this histogram later // you should call Sumw2 before making this operation. // This is particularly important if you fit the histogram after TH1::Scale // // One can scale an histogram such that the bins integral is equal to // the normalization parameter via TH1::Scale(Double_t norm), where norm // is the desired normalization divided by the integral of the histogram. // // If option contains "width" the bin contents and errors are divided // by the bin width. TString opt = option; opt.ToLower(); Double_t ent = fEntries; if (opt.Contains("width")) Add(this,this,c1,-1); else Add(this,this,c1,0); fEntries = ent; //if contours set, must also scale contours Int_t ncontours = GetContour(); if (ncontours == 0) return; Double_t *levels = fContour.GetArray(); for (Int_t i=0;i<ncontours;i++) { levels[i] *= c1; } } //______________________________________________________________________________ void TH1::SetDefaultBufferSize(Int_t buffersize) { // static function to set the default buffer size for automatic histograms. // When an histogram is created with one of its axis lower limit greater // or equal to its upper limit, the function SetBuffer is automatically // called with the default buffer size. if (buffersize < 0) buffersize = 0; fgBufferSize = buffersize; } //______________________________________________________________________________ void TH1::SetDefaultSumw2(Bool_t sumw2) { // static function. // When this static function is called with sumw2=kTRUE, all new // histograms will automatically activate the storage // of the sum of squares of errors, ie TH1::Sumw2 is automatically called. fgDefaultSumw2 = sumw2; } //______________________________________________________________________________ void TH1::SetTitle(const char *title) { // Change (i.e. set) the title // // if title is in the form "stringt;stringx;stringy;stringz" // the histogram title is set to stringt, the x axis title to stringx, // the y axis title to stringy, and the z axis title to stringz. // To insert the character ";" in one of the titles, one should use "#;" // or "#semicolon". fTitle = title; fTitle.ReplaceAll("#;",2,"#semicolon",10); // Decode fTitle. It may contain X, Y and Z titles TString str1 = fTitle, str2; Int_t isc = str1.Index(";"); Int_t lns = str1.Length(); if (isc >=0 ) { fTitle = str1(0,isc); str1 = str1(isc+1, lns); isc = str1.Index(";"); if (isc >=0 ) { str2 = str1(0,isc); str2.ReplaceAll("#semicolon",10,";",1); fXaxis.SetTitle(str2.Data()); lns = str1.Length(); str1 = str1(isc+1, lns); isc = str1.Index(";"); if (isc >=0 ) { str2 = str1(0,isc); str2.ReplaceAll("#semicolon",10,";",1); fYaxis.SetTitle(str2.Data()); lns = str1.Length(); str1 = str1(isc+1, lns); str1.ReplaceAll("#semicolon",10,";",1); fZaxis.SetTitle(str1.Data()); } else { str1.ReplaceAll("#semicolon",10,";",1); fYaxis.SetTitle(str1.Data()); } } else { str1.ReplaceAll("#semicolon",10,";",1); fXaxis.SetTitle(str1.Data()); } } fTitle.ReplaceAll("#semicolon",10,";",1); if (gPad && TestBit(kMustCleanup)) gPad->Modified(); } // ------------------------------------------------------------------------- void TH1::SmoothArray(Int_t nn, Double_t *xx, Int_t ntimes) { // smooth array xx, translation of Hbook routine hsmoof.F // based on algorithm 353QH twice presented by J. Friedman // in Proc.of the 1974 CERN School of Computing, Norway, 11-24 August, 1974. if (nn < 3 ) { ::Error("SmoothArray","Need at least 3 points for smoothing: n = %d",nn); return; } Int_t ii; Double_t hh[6] = {0,0,0,0,0,0}; std::vector<double> yy(nn); std::vector<double> zz(nn); std::vector<double> rr(nn); for (Int_t pass=0;pass<ntimes;pass++) { // first copy original data into temp array std::copy(xx, xx+nn, zz.begin() ); for (int noent = 0; noent < 2; ++noent) { // run algorithm two times // do 353 i.e. running median 3, 5, and 3 in a single loop for (int kk = 0; kk < 3; kk++) { std::copy(zz.begin(), zz.end(), yy.begin()); int medianType = (kk != 1) ? 3 : 5; int ifirst = (kk != 1 ) ? 1 : 2; int ilast = (kk != 1 ) ? nn-1 : nn -2; //nn2 = nn - ik - 1; // do all elements beside the first and last point for median 3 // and first two and last 2 for median 5 for ( ii = ifirst; ii < ilast; ii++) { assert(ii - ifirst >= 0); for (int jj = 0; jj < medianType; jj++) { hh[jj] = yy[ii - ifirst + jj ]; } zz[ii] = TMath::Median(medianType, hh); } if (kk == 0) { // first median 3 // first point hh[0] = zz[1]; hh[1] = zz[0]; hh[2] = 3*zz[1] - 2*zz[2]; zz[0] = TMath::Median(3, hh); // last point hh[0] = zz[nn - 2]; hh[1] = zz[nn - 1]; hh[2] = 3*zz[nn - 2] - 2*zz[nn - 3]; zz[nn - 1] = TMath::Median(3, hh); } if (kk == 1) { // median 5 for (ii = 0; ii < 3; ii++) { hh[ii] = yy[ii]; } zz[1] = TMath::Median(3, hh); // last two points for (ii = 0; ii < 3; ii++) { hh[ii] = yy[nn - 3 + ii]; } zz[nn - 2] = TMath::Median(3, hh); } } std::copy ( zz.begin(), zz.end(), yy.begin() ); // quadratic interpolation for flat segments for (ii = 2; ii < (nn - 2); ii++) { if (zz[ii - 1] != zz[ii]) continue; if (zz[ii] != zz[ii + 1]) continue; hh[0] = zz[ii - 2] - zz[ii]; hh[1] = zz[ii + 2] - zz[ii]; if (hh[0] * hh[1] <= 0) continue; int jk = 1; if ( TMath::Abs(hh[1]) > TMath::Abs(hh[0]) ) jk = -1; yy[ii] = -0.5*zz[ii - 2*jk] + zz[ii]/0.75 + zz[ii + 2*jk] /6.; yy[ii + jk] = 0.5*(zz[ii + 2*jk] - zz[ii - 2*jk]) + zz[ii]; } // running means //std::copy(zz.begin(), zz.end(), yy.begin()); for (ii = 1; ii < nn - 1; ii++) { zz[ii] = 0.25*yy[ii - 1] + 0.5*yy[ii] + 0.25*yy[ii + 1]; } zz[0] = yy[0]; zz[nn - 1] = yy[nn - 1]; if (noent == 0) { // save computed values std::copy(zz.begin(), zz.end(), rr.begin()); // COMPUTE residuals for (ii = 0; ii < nn; ii++) { zz[ii] = xx[ii] - zz[ii]; } } } // end loop on noent double xmin = TMath::MinElement(nn,xx); for (ii = 0; ii < nn; ii++) { if (xmin < 0) xx[ii] = rr[ii] + zz[ii]; // make smoothing defined positive - not better using 0 ? else xx[ii] = TMath::Max((rr[ii] + zz[ii]),0.0 ); } } } // ------------------------------------------------------------------------ void TH1::Smooth(Int_t ntimes, Option_t *option) { // Smooth bin contents of this histogram. // if option contains "R" smoothing is applied only to the bins // defined in the X axis range (default is to smooth all bins) // Bin contents are replaced by their smooth values. // Errors (if any) are not modified. // the smoothing procedure is repeated ntimes (default=1) if (fDimension != 1) { Error("Smooth","Smooth only supported for 1-d histograms"); return; } Int_t nbins = fXaxis.GetNbins(); if (nbins < 3) { Error("Smooth","Smooth only supported for histograms with >= 3 bins. Nbins = %d",nbins); return; } // delete buffer if it is there since it will become invalid if (fBuffer) BufferEmpty(1); Int_t firstbin = 1, lastbin = nbins; TString opt = option; opt.ToLower(); if (opt.Contains("r")) { firstbin= fXaxis.GetFirst(); lastbin = fXaxis.GetLast(); } nbins = lastbin - firstbin + 1; Double_t *xx = new Double_t[nbins]; Double_t nent = fEntries; Int_t i; for (i=0;i<nbins;i++) { xx[i] = GetBinContent(i+firstbin); } TH1::SmoothArray(nbins,xx,ntimes); for (i=0;i<nbins;i++) { SetBinContent(i+firstbin,xx[i]); } fEntries = nent; delete [] xx; if (gPad) gPad->Modified(); } // ------------------------------------------------------------------------ void TH1::StatOverflows(Bool_t flag) { // if flag=kTRUE, underflows and overflows are used by the Fill functions // in the computation of statistics (mean value, RMS). // By default, underflows or overflows are not used. fgStatOverflows = flag; } //_______________________________________________________________________ void TH1::Streamer(TBuffer &b) { // -*-*-*-*-*-*-*Stream a class object*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* // ===================== if (b.IsReading()) { UInt_t R__s, R__c; Version_t R__v = b.ReadVersion(&R__s, &R__c); if (fDirectory) fDirectory->Remove(this); fDirectory = 0; if (R__v > 2) { b.ReadClassBuffer(TH1::Class(), this, R__v, R__s, R__c); ResetBit(kMustCleanup); fXaxis.SetParent(this); fYaxis.SetParent(this); fZaxis.SetParent(this); TIter next(fFunctions); TObject *obj; while ((obj=next())) { if (obj->InheritsFrom(TF1::Class())) ((TF1*)obj)->SetParent(this); } return; } //process old versions before automatic schema evolution TNamed::Streamer(b); TAttLine::Streamer(b); TAttFill::Streamer(b); TAttMarker::Streamer(b); b >> fNcells; fXaxis.Streamer(b); fYaxis.Streamer(b); fZaxis.Streamer(b); fXaxis.SetParent(this); fYaxis.SetParent(this); fZaxis.SetParent(this); b >> fBarOffset; b >> fBarWidth; b >> fEntries; b >> fTsumw; b >> fTsumw2; b >> fTsumwx; b >> fTsumwx2; if (R__v < 2) { Float_t maximum, minimum, norm; Float_t *contour=0; b >> maximum; fMaximum = maximum; b >> minimum; fMinimum = minimum; b >> norm; fNormFactor = norm; Int_t n = b.ReadArray(contour); fContour.Set(n); for (Int_t i=0;i<n;i++) fContour.fArray[i] = contour[i]; delete [] contour; } else { b >> fMaximum; b >> fMinimum; b >> fNormFactor; fContour.Streamer(b); } fSumw2.Streamer(b); fOption.Streamer(b); fFunctions->Delete(); fFunctions->Streamer(b); b.CheckByteCount(R__s, R__c, TH1::IsA()); } else { b.WriteClassBuffer(TH1::Class(),this); } } //______________________________________________________________________________ void TH1::Print(Option_t *option) const { // -*-*-*-*-*Print some global quantities for this histogram*-*-*-*-*-*-*-* // =============================================== // // If option "base" is given, number of bins and ranges are also printed // If option "range" is given, bin contents and errors are also printed // for all bins in the current range (default 1-->nbins) // If option "all" is given, bin contents and errors are also printed // for all bins including under and overflows. printf( "TH1.Print Name = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(GetEntries()),GetSumOfWeights()); TString opt = option; opt.ToLower(); Int_t all; if (opt.Contains("all")) all = 0; else if (opt.Contains("range")) all = 1; else if (opt.Contains("base")) all = 2; else return; Int_t bin, binx, biny, binz; Int_t firstx=0,lastx=0,firsty=0,lasty=0,firstz=0,lastz=0; if (all == 0) { lastx = fXaxis.GetNbins()+1; if (fDimension > 1) lasty = fYaxis.GetNbins()+1; if (fDimension > 2) lastz = fZaxis.GetNbins()+1; } else { firstx = fXaxis.GetFirst(); lastx = fXaxis.GetLast(); if (fDimension > 1) {firsty = fYaxis.GetFirst(); lasty = fYaxis.GetLast();} if (fDimension > 2) {firstz = fZaxis.GetFirst(); lastz = fZaxis.GetLast();} } if (all== 2) { printf(" Title = %s\n", GetTitle()); printf(" NbinsX= %d, xmin= %g, xmax=%g", fXaxis.GetNbins(), fXaxis.GetXmin(), fXaxis.GetXmax()); if( fDimension > 1) printf(", NbinsY= %d, ymin= %g, ymax=%g", fYaxis.GetNbins(), fYaxis.GetXmin(), fYaxis.GetXmax()); if( fDimension > 2) printf(", NbinsZ= %d, zmin= %g, zmax=%g", fZaxis.GetNbins(), fZaxis.GetXmin(), fZaxis.GetXmax()); printf("\n"); return; } Double_t w,e; Double_t x,y,z; if (fDimension == 1) { for (binx=firstx;binx<=lastx;binx++) { x = fXaxis.GetBinCenter(binx); w = GetBinContent(binx); e = GetBinError(binx); if(fSumw2.fN) printf(" fSumw[%d]=%g, x=%g, error=%g\n",binx,w,x,e); else printf(" fSumw[%d]=%g, x=%g\n",binx,w,x); } } if (fDimension == 2) { for (biny=firsty;biny<=lasty;biny++) { y = fYaxis.GetBinCenter(biny); for (binx=firstx;binx<=lastx;binx++) { bin = GetBin(binx,biny); x = fXaxis.GetBinCenter(binx); w = GetBinContent(bin); e = GetBinError(bin); if(fSumw2.fN) printf(" fSumw[%d][%d]=%g, x=%g, y=%g, error=%g\n",binx,biny,w,x,y,e); else printf(" fSumw[%d][%d]=%g, x=%g, y=%g\n",binx,biny,w,x,y); } } } if (fDimension == 3) { for (binz=firstz;binz<=lastz;binz++) { z = fZaxis.GetBinCenter(binz); for (biny=firsty;biny<=lasty;biny++) { y = fYaxis.GetBinCenter(biny); for (binx=firstx;binx<=lastx;binx++) { bin = GetBin(binx,biny,binz); x = fXaxis.GetBinCenter(binx); w = GetBinContent(bin); e = GetBinError(bin); if(fSumw2.fN) printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g, error=%g\n",binx,biny,binz,w,x,y,z,e); else printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g\n",binx,biny,binz,w,x,y,z); } } } } } //______________________________________________________________________________ void TH1::Rebuild(Option_t *) { // Using the current bin info, recompute the arrays for contents and errors SetBinsLength(); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::Reset(Option_t *option) { // -*-*-*-*-*-*Reset this histogram: contents, errors, etc*-*-*-*-*-*-*-* // =========================================== // // if option "ICE" is specified, resets only Integral, Contents and Errors. // if option "ICES" is specified, resets only Integral, Contents , Errors and Statistics // This option is used // if option "M" is specified, resets also Minimum and Maximum // The option "ICE" is used when rebinning the histogram (in RebinAxis, LabelInflate, etc..) // The option "ICES is used in combination with the buffer (see BufferEmpty and BufferFill) TString opt = option; opt.ToUpper(); fSumw2.Reset(); if (fIntegral) {delete [] fIntegral; fIntegral = 0;} if (opt.Contains("M")) { SetMinimum(); SetMaximum(); } if (opt.Contains("ICE") && !opt.Contains("S")) return; // Setting fBuffer[0] = 0 is like resetting the buffer but not deleting it // But what is the sense of calling BufferEmpty() ? For making the axes ? // BufferEmpty will update contents that later will be // reset in calling TH1D::Reset. For this we need to reset the stats afterwards // It may be needed for computing the axis limits.... if (fBuffer) {BufferEmpty(); fBuffer[0] = 0;} // need to reset also the statistics // (needs to be done after calling BufferEmpty() ) fTsumw = 0; fTsumw2 = 0; fTsumwx = 0; fTsumwx2 = 0; fEntries = 0; if (opt == "ICES") return; TObject *stats = fFunctions->FindObject("stats"); fFunctions->Remove(stats); //special logic to support the case where the same object is //added multiple times in fFunctions. //This case happens when the same object is added with different //drawing modes TObject *obj; while ((obj = fFunctions->First())) { while(fFunctions->Remove(obj)) { } delete obj; } if(stats) fFunctions->Add(stats); fContour.Set(0); } //______________________________________________________________________________ void TH1::SavePrimitive(ostream &out, Option_t *option /*= ""*/) { // Save primitive as a C++ statement(s) on output stream out Bool_t nonEqiX = kFALSE; Bool_t nonEqiY = kFALSE; Bool_t nonEqiZ = kFALSE; Int_t i; static Int_t nxaxis = 0; static Int_t nyaxis = 0; static Int_t nzaxis = 0; TString sxaxis="xAxis",syaxis="yAxis",szaxis="zAxis"; // Check if the histogram has equidistant X bins or not. If not, we // create an array holding the bins. if (GetXaxis()->GetXbins()->fN && GetXaxis()->GetXbins()->fArray) { nonEqiX = kTRUE; nxaxis++; sxaxis += nxaxis; out << " Double_t "<<sxaxis<<"[" << GetXaxis()->GetXbins()->fN << "] = {"; for (i = 0; i < GetXaxis()->GetXbins()->fN; i++) { if (i != 0) out << ", "; out << GetXaxis()->GetXbins()->fArray[i]; } out << "}; " << endl; } // If the histogram is 2 or 3 dimensional, check if the histogram // has equidistant Y bins or not. If not, we create an array // holding the bins. if (fDimension > 1 && GetYaxis()->GetXbins()->fN && GetYaxis()->GetXbins()->fArray) { nonEqiY = kTRUE; nyaxis++; syaxis += nyaxis; out << " Double_t "<<syaxis<<"[" << GetYaxis()->GetXbins()->fN << "] = {"; for (i = 0; i < GetYaxis()->GetXbins()->fN; i++) { if (i != 0) out << ", "; out << GetYaxis()->GetXbins()->fArray[i]; } out << "}; " << endl; } // IF the histogram is 3 dimensional, check if the histogram // has equidistant Z bins or not. If not, we create an array // holding the bins. if (fDimension > 2 && GetZaxis()->GetXbins()->fN && GetZaxis()->GetXbins()->fArray) { nonEqiZ = kTRUE; nzaxis++; szaxis += nzaxis; out << " Double_t "<<szaxis<<"[" << GetZaxis()->GetXbins()->fN << "] = {"; for (i = 0; i < GetZaxis()->GetXbins()->fN; i++) { if (i != 0) out << ", "; out << GetZaxis()->GetXbins()->fArray[i]; } out << "}; " << endl; } char quote = '"'; out <<" "<<endl; out <<" "<< ClassName() <<" *"; // Histogram pointer has by default the histogram name. // However, in case the histogram has no directory, it is safer to add a incremental suffix. // If the histogram belongs to a graph or a stack the suffix is not added because // the graph and stack objects are not aware of this new name. Same thing if // the histogram is drawn with the option COLZ because the TPaletteAxis drawn // when this option is selected, does not know this new name either. TString opt = option; opt.ToLower(); static Int_t hcounter = 0; TString histName = GetName(); if (!fDirectory && !histName.Contains("Graph") && !histName.Contains("_stack_") && !opt.Contains("colz")) { hcounter++; histName += "__"; histName += hcounter; } const char *hname = histName.Data(); if (!strlen(hname)) hname = "unnamed"; TString t(GetTitle()); t.ReplaceAll("\\","\\\\"); t.ReplaceAll("\"","\\\""); out << hname << " = new " << ClassName() << "(" << quote << hname << quote << "," << quote<< t.Data() << quote << "," << GetXaxis()->GetNbins(); if (nonEqiX) out << ", "<<sxaxis; else out << "," << GetXaxis()->GetXmin() << "," << GetXaxis()->GetXmax(); if (fDimension > 1) { out << "," << GetYaxis()->GetNbins(); if (nonEqiY) out << ", "<<syaxis; else out << "," << GetYaxis()->GetXmin() << "," << GetYaxis()->GetXmax(); } if (fDimension > 2) { out << "," << GetZaxis()->GetNbins(); if (nonEqiZ) out << ", "<<szaxis; else out << "," << GetZaxis()->GetXmin() << "," << GetZaxis()->GetXmax(); } out << ");" << endl; // save bin contents Int_t bin; for (bin=0;bin<fNcells;bin++) { Double_t bc = GetBinContent(bin); if (bc) { out<<" "<<hname<<"->SetBinContent("<<bin<<","<<bc<<");"<<endl; } } // save bin errors if (fSumw2.fN) { for (bin=0;bin<fNcells;bin++) { Double_t be = GetBinError(bin); if (be) { out<<" "<<hname<<"->SetBinError("<<bin<<","<<be<<");"<<endl; } } } TH1::SavePrimitiveHelp(out, hname, option); } //______________________________________________________________________________ void TH1::SavePrimitiveHelp(ostream &out, const char *hname, Option_t *option /*= ""*/) { // helper function for the SavePrimitive functions from TH1 // or classes derived from TH1, eg TProfile, TProfile2D. char quote = '"'; if (TMath::Abs(GetBarOffset()) > 1e-5) { out<<" "<<hname<<"->SetBarOffset("<<GetBarOffset()<<");"<<endl; } if (TMath::Abs(GetBarWidth()-1) > 1e-5) { out<<" "<<hname<<"->SetBarWidth("<<GetBarWidth()<<");"<<endl; } if (fMinimum != -1111) { out<<" "<<hname<<"->SetMinimum("<<fMinimum<<");"<<endl; } if (fMaximum != -1111) { out<<" "<<hname<<"->SetMaximum("<<fMaximum<<");"<<endl; } if (fNormFactor != 0) { out<<" "<<hname<<"->SetNormFactor("<<fNormFactor<<");"<<endl; } if (fEntries != 0) { out<<" "<<hname<<"->SetEntries("<<fEntries<<");"<<endl; } if (fDirectory == 0) { out<<" "<<hname<<"->SetDirectory(0);"<<endl; } if (TestBit(kNoStats)) { out<<" "<<hname<<"->SetStats(0);"<<endl; } if (fOption.Length() != 0) { out<<" "<<hname<<"->SetOption("<<quote<<fOption.Data()<<quote<<");"<<endl; } // save contour levels Int_t ncontours = GetContour(); if (ncontours > 0) { out<<" "<<hname<<"->SetContour("<<ncontours<<");"<<endl; Double_t zlevel; for (Int_t bin=0;bin<ncontours;bin++) { if (gPad->GetLogz()) { zlevel = TMath::Power(10,GetContourLevel(bin)); } else { zlevel = GetContourLevel(bin); } out<<" "<<hname<<"->SetContourLevel("<<bin<<","<<zlevel<<");"<<endl; } } // save list of functions TObjOptLink *lnk = (TObjOptLink*)fFunctions->FirstLink(); TObject *obj; while (lnk) { obj = lnk->GetObject(); obj->SavePrimitive(out,"nodraw"); if (obj->InheritsFrom(TF1::Class())) { out<<" "<<hname<<"->GetListOfFunctions()->Add("<<obj->GetName()<<");"<<endl; } else if (obj->InheritsFrom("TPaveStats")) { out<<" "<<hname<<"->GetListOfFunctions()->Add(ptstats);"<<endl; out<<" ptstats->SetParent("<<hname<<");"<<endl; } else { out<<" "<<hname<<"->GetListOfFunctions()->Add("<<obj->GetName()<<","<<quote<<lnk->GetOption()<<quote<<");"<<endl; } lnk = (TObjOptLink*)lnk->Next(); } // save attributes SaveFillAttributes(out,hname,0,1001); SaveLineAttributes(out,hname,1,1,1); SaveMarkerAttributes(out,hname,1,1,1); fXaxis.SaveAttributes(out,hname,"->GetXaxis()"); fYaxis.SaveAttributes(out,hname,"->GetYaxis()"); fZaxis.SaveAttributes(out,hname,"->GetZaxis()"); TString opt = option; opt.ToLower(); if (!opt.Contains("nodraw")) { out<<" "<<hname<<"->Draw(" <<quote<<option<<quote<<");"<<endl; } } //______________________________________________________________________________ void TH1::UseCurrentStyle() { // Copy current attributes from/to current style if (!gStyle) return; if (gStyle->IsReading()) { fXaxis.ResetAttAxis("X"); fYaxis.ResetAttAxis("Y"); fZaxis.ResetAttAxis("Z"); SetBarOffset(gStyle->GetBarOffset()); SetBarWidth(gStyle->GetBarWidth()); SetFillColor(gStyle->GetHistFillColor()); SetFillStyle(gStyle->GetHistFillStyle()); SetLineColor(gStyle->GetHistLineColor()); SetLineStyle(gStyle->GetHistLineStyle()); SetLineWidth(gStyle->GetHistLineWidth()); SetMarkerColor(gStyle->GetMarkerColor()); SetMarkerStyle(gStyle->GetMarkerStyle()); SetMarkerSize(gStyle->GetMarkerSize()); Int_t dostat = gStyle->GetOptStat(); if (gStyle->GetOptFit() && !dostat) dostat = 1000000001; SetStats(dostat); } else { gStyle->SetBarOffset(fBarOffset); gStyle->SetBarWidth(fBarWidth); gStyle->SetHistFillColor(GetFillColor()); gStyle->SetHistFillStyle(GetFillStyle()); gStyle->SetHistLineColor(GetLineColor()); gStyle->SetHistLineStyle(GetLineStyle()); gStyle->SetHistLineWidth(GetLineWidth()); gStyle->SetMarkerColor(GetMarkerColor()); gStyle->SetMarkerStyle(GetMarkerStyle()); gStyle->SetMarkerSize(GetMarkerSize()); gStyle->SetOptStat(TestBit(kNoStats)); } TIter next(GetListOfFunctions()); TObject *obj; while ((obj = next())) { obj->UseCurrentStyle(); } } //______________________________________________________________________________ Double_t TH1::GetMean(Int_t axis) const { // For axis = 1,2 or 3 returns the mean value of the histogram along // X,Y or Z axis. // For axis = 11, 12, 13 returns the standard error of the mean value // of the histogram along X, Y or Z axis // // Note that the mean value/RMS is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. // -*-*-*-*-*-*Return mean value of this histogram along the X axis*-*-*-*-* // ==================================================== // Note that the mean value/RMS is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. if (axis<1 || (axis>3 && axis<11) || axis>13) return 0; Double_t stats[kNstat]; for (Int_t i=4;i<kNstat;i++) stats[i] = 0; GetStats(stats); if (stats[0] == 0) return 0; if (axis<4){ Int_t ax[3] = {2,4,7}; return stats[ax[axis-1]]/stats[0]; } else { // mean error = RMS / sqrt( Neff ) Double_t rms = GetRMS(axis-10); Double_t neff = GetEffectiveEntries(); return ( neff > 0 ? rms/TMath::Sqrt(neff) : 0. ); } } //______________________________________________________________________________ Double_t TH1::GetMeanError(Int_t axis) const { // -*-*-*-*-*-*Return standard error of mean of this histogram along the X axis*-*-*-*-* // ==================================================== // Note that the mean value/RMS is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. // Also note, that although the definition of standard error doesn't include the // assumption of normality, many uses of this feature implicitly assume it. return GetMean(axis+10); } //______________________________________________________________________________ Double_t TH1::GetRMS(Int_t axis) const { // For axis = 1,2 or 3 returns the Sigma value of the histogram along // X, Y or Z axis // For axis = 11, 12 or 13 returns the error of RMS estimation along // X, Y or Z axis for Normal distribution // // Note that the mean value/sigma is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. // Note that this function returns the Standard Deviation (Sigma) // of the distribution (not RMS). // The Sigma estimate is computed as Sqrt((1/N)*(Sum(x_i-x_mean)^2)) // The name "RMS" was introduced many years ago (Hbook/PAW times). // We kept the name for continuity. if (axis<1 || (axis>3 && axis<11) || axis>13) return 0; Double_t x, rms2, stats[kNstat]; for (Int_t i=4;i<kNstat;i++) stats[i] = 0; GetStats(stats); if (stats[0] == 0) return 0; Int_t ax[3] = {2,4,7}; Int_t axm = ax[axis%10 - 1]; x = stats[axm]/stats[0]; rms2 = TMath::Abs(stats[axm+1]/stats[0] -x*x); if (axis<10) return TMath::Sqrt(rms2); else { // The right formula for RMS error depends on 4th momentum (see Kendall-Stuart Vol 1 pag 243) // formula valid for only gaussian distribution ( 4-th momentum = 3 * sigma^4 ) Double_t neff = GetEffectiveEntries(); return ( neff > 0 ? TMath::Sqrt(rms2/(2*neff) ) : 0. ); } } //______________________________________________________________________________ Double_t TH1::GetRMSError(Int_t axis) const { // Return error of RMS estimation for Normal distribution // // Note that the mean value/RMS is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. // Value returned is standard deviation of sample standard deviation. // Note that it is an approximated value which is valid only in the case that the // original data distribution is Normal. The correct one would require // the 4-th momentum value, which cannot be accurately estimated from an histogram since // the x-information for all entries is not kept. return GetRMS(axis+10); } //______________________________________________________________________________ Double_t TH1::GetSkewness(Int_t axis) const { //For axis = 1, 2 or 3 returns skewness of the histogram along x, y or z axis. //For axis = 11, 12 or 13 returns the approximate standard error of skewness //of the histogram along x, y or z axis //Note, that since third and fourth moment are not calculated //at the fill time, skewness and its standard error are computed bin by bin if (axis > 0 && axis <= 3){ Double_t mean = GetMean(axis); Double_t rms = GetRMS(axis); Double_t rms3 = rms*rms*rms; Int_t firstBinX = fXaxis.GetFirst(); Int_t lastBinX = fXaxis.GetLast(); Int_t firstBinY = fYaxis.GetFirst(); Int_t lastBinY = fYaxis.GetLast(); Int_t firstBinZ = fZaxis.GetFirst(); Int_t lastBinZ = fZaxis.GetLast(); // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis if (fgStatOverflows) { if ( !fXaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinX == 1) firstBinX = 0; if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1; } if ( !fYaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinY == 1) firstBinY = 0; if (lastBinY == fYaxis.GetNbins() ) lastBinY += 1; } if ( !fZaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinZ == 1) firstBinZ = 0; if (lastBinZ == fZaxis.GetNbins() ) lastBinZ += 1; } } Double_t x = 0; Double_t sum=0; Double_t np=0; for (Int_t binx = firstBinX; binx <= lastBinX; binx++) { for (Int_t biny = firstBinY; biny <= lastBinY; biny++) { for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) { if (axis==1 ) x = fXaxis.GetBinCenter(binx); else if (axis==2 ) x = fYaxis.GetBinCenter(biny); else if (axis==3 ) x = fZaxis.GetBinCenter(binz); Double_t w = GetBinContent(binx,biny,binz); np+=w; sum+=w*(x-mean)*(x-mean)*(x-mean); } } } sum/=np*rms3; return sum; } else if (axis > 10 && axis <= 13) { //compute standard error of skewness // assume parent normal distribution use formula from Kendall-Stuart, Vol 1 pag 243, second edition Double_t neff = GetEffectiveEntries(); return ( neff > 0 ? TMath::Sqrt(6./neff ) : 0. ); } else { Error("GetSkewness", "illegal value of parameter"); return 0; } } //______________________________________________________________________________ Double_t TH1::GetKurtosis(Int_t axis) const { //For axis =1, 2 or 3 returns kurtosis of the histogram along x, y or z axis. //Kurtosis(gaussian(0, 1)) = 0. //For axis =11, 12 or 13 returns the approximate standard error of kurtosis //of the histogram along x, y or z axis //Note, that since third and fourth moment are not calculated //at the fill time, kurtosis and its standard error are computed bin by bin if (axis > 0 && axis <= 3){ Double_t mean = GetMean(axis); Double_t rms = GetRMS(axis); Double_t rms4 = rms*rms*rms*rms; Int_t firstBinX = fXaxis.GetFirst(); Int_t lastBinX = fXaxis.GetLast(); Int_t firstBinY = fYaxis.GetFirst(); Int_t lastBinY = fYaxis.GetLast(); Int_t firstBinZ = fZaxis.GetFirst(); Int_t lastBinZ = fZaxis.GetLast(); // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis if (fgStatOverflows) { if ( !fXaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinX == 1) firstBinX = 0; if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1; } if ( !fYaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinY == 1) firstBinY = 0; if (lastBinY == fYaxis.GetNbins() ) lastBinY += 1; } if ( !fZaxis.TestBit(TAxis::kAxisRange) ) { if (firstBinZ == 1) firstBinZ = 0; if (lastBinZ == fZaxis.GetNbins() ) lastBinZ += 1; } } Double_t x = 0; Double_t sum=0; Double_t np=0; for (Int_t binx = firstBinX; binx <= lastBinX; binx++) { for (Int_t biny = firstBinY; biny <= lastBinY; biny++) { for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) { if (axis==1 ) x = fXaxis.GetBinCenter(binx); else if (axis==2 ) x = fYaxis.GetBinCenter(biny); else if (axis==3 ) x = fZaxis.GetBinCenter(binz); Double_t w = GetBinContent(binx,biny,binz); np+=w; sum+=w*(x-mean)*(x-mean)*(x-mean)*(x-mean); } } } sum/=(np*rms4); return sum-3; } else if (axis > 10 && axis <= 13) { //compute standard error of skewness // assume parent normal distribution use formula from Kendall-Stuart, Vol 1 pag 243, second edition Double_t neff = GetEffectiveEntries(); return ( neff > 0 ? TMath::Sqrt(24./neff ) : 0. ); } else { Error("GetKurtosis", "illegal value of parameter"); return 0; } } //______________________________________________________________________________ void TH1::GetStats(Double_t *stats) const { // fill the array stats from the contents of this histogram // The array stats must be correctly dimensioned in the calling program. // stats[0] = sumw // stats[1] = sumw2 // stats[2] = sumwx // stats[3] = sumwx2 // // If no axis-subrange is specified (via TAxis::SetRange), the array stats // is simply a copy of the statistics quantities computed at filling time. // If a sub-range is specified, the function recomputes these quantities // from the bin contents in the current axis range. // // Note that the mean value/RMS is computed using the bins in the currently // defined range (see TAxis::SetRange). By default the range includes // all bins from 1 to nbins included, excluding underflows and overflows. // To force the underflows and overflows in the computation, one must // call the static function TH1::StatOverflows(kTRUE) before filling // the histogram. if (fBuffer) ((TH1*)this)->BufferEmpty(); // Loop on bins (possibly including underflows/overflows) Int_t bin, binx; Double_t w,err; Double_t x; // case of labels with rebin of axis set // statistics in x does not make any sense - set to zero if ((const_cast<TAxis&>(fXaxis)).GetLabels() && TestBit(TH1::kCanRebin) ) { stats[0] = fTsumw; stats[1] = fTsumw2; stats[2] = 0; stats[3] = 0; } else if ((fTsumw == 0 && fEntries > 0) || fXaxis.TestBit(TAxis::kAxisRange)) { for (bin=0;bin<4;bin++) stats[bin] = 0; Int_t firstBinX = fXaxis.GetFirst(); Int_t lastBinX = fXaxis.GetLast(); // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis if (fgStatOverflows && !fXaxis.TestBit(TAxis::kAxisRange)) { if (firstBinX == 1) firstBinX = 0; if (lastBinX == fXaxis.GetNbins() ) lastBinX += 1; } for (binx = firstBinX; binx <= lastBinX; binx++) { x = fXaxis.GetBinCenter(binx); //w = TMath::Abs(GetBinContent(binx)); // not sure what to do here if w < 0 w = GetBinContent(binx); err = TMath::Abs(GetBinError(binx)); stats[0] += w; stats[1] += err*err; stats[2] += w*x; stats[3] += w*x*x; } // if (stats[0] < 0) { // // in case total is negative do something ?? // stats[0] = 0; // } } else { stats[0] = fTsumw; stats[1] = fTsumw2; stats[2] = fTsumwx; stats[3] = fTsumwx2; } } //______________________________________________________________________________ void TH1::PutStats(Double_t *stats) { // Replace current statistics with the values in array stats fTsumw = stats[0]; fTsumw2 = stats[1]; fTsumwx = stats[2]; fTsumwx2 = stats[3]; } //______________________________________________________________________________ void TH1::ResetStats() { // Reset the statistics including the number of entries // and replace with values calculates from bin content // The number of entries is set to the total bin content or (in case of weighted histogram) // to number of effective entries Double_t stats[kNstat] = {0}; fTsumw = 0; fEntries = 1; // to force re-calculation of the statistics in TH1::GetStats GetStats(stats); PutStats(stats); fEntries = TMath::Abs(fTsumw); // use effective entries for weighted histograms: (sum_w) ^2 / sum_w2 if (fSumw2.fN > 0 && fTsumw > 0 && stats[1] > 0 ) fEntries = stats[0]*stats[0]/ stats[1]; } //______________________________________________________________________________ Double_t TH1::GetSumOfWeights() const { // -*-*-*-*-*-*Return the sum of weights excluding under/overflows*-*-*-*-* // =================================================== Int_t bin,binx,biny,binz; Double_t sum =0; for(binz=1; binz<=fZaxis.GetNbins(); binz++) { for(biny=1; biny<=fYaxis.GetNbins(); biny++) { for(binx=1; binx<=fXaxis.GetNbins(); binx++) { bin = GetBin(binx,biny,binz); sum += GetBinContent(bin); } } } return sum; } //______________________________________________________________________________ Double_t TH1::Integral(Option_t *option) const { //Return integral of bin contents. Only bins in the bins range are considered. // By default the integral is computed as the sum of bin contents in the range. // if option "width" is specified, the integral is the sum of // the bin contents multiplied by the bin width in x. return Integral(fXaxis.GetFirst(),fXaxis.GetLast(),option); } //______________________________________________________________________________ Double_t TH1::Integral(Int_t binx1, Int_t binx2, Option_t *option) const { //Return integral of bin contents in range [binx1,binx2] // By default the integral is computed as the sum of bin contents in the range. // if option "width" is specified, the integral is the sum of // the bin contents multiplied by the bin width in x. double err = 0; return DoIntegral(binx1,binx2,0,-1,0,-1,err,option); } //______________________________________________________________________________ Double_t TH1::IntegralAndError(Int_t binx1, Int_t binx2, Double_t & error, Option_t *option) const { //Return integral of bin contents in range [binx1,binx2] and its error // By default the integral is computed as the sum of bin contents in the range. // if option "width" is specified, the integral is the sum of // the bin contents multiplied by the bin width in x. // the error is computed using error propagation from the bin errors assumming that // all the bins are uncorrelated return DoIntegral(binx1,binx2,0,-1,0,-1,error,option,kTRUE); } //______________________________________________________________________________ Double_t TH1::DoIntegral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Int_t binz1, Int_t binz2, Double_t & error , Option_t *option, Bool_t doError) const { // internal function compute integral and optionally the error between the limits // specified by the bin number values working for all histograms (1D, 2D and 3D) Int_t nbinsx = GetNbinsX(); if (binx1 < 0) binx1 = 0; if (binx2 > nbinsx+1 || binx2 < binx1) binx2 = nbinsx+1; if (GetDimension() > 1) { Int_t nbinsy = GetNbinsY(); if (biny1 < 0) biny1 = 0; if (biny2 > nbinsy+1 || biny2 < biny1) biny2 = nbinsy+1; } else { biny1 = 0; biny2 = 0; } if (GetDimension() > 2) { Int_t nbinsz = GetNbinsZ(); if (binz1 < 0) binz1 = 0; if (binz2 > nbinsz+1 || binz2 < binz1) binz2 = nbinsz+1; } else { binz1 = 0; binz2 = 0; } // - Loop on bins in specified range TString opt = option; opt.ToLower(); Bool_t width = kFALSE; if (opt.Contains("width")) width = kTRUE; Double_t dx = 1.; Double_t dy = 1.; Double_t dz = 1.; Double_t integral = 0; Double_t igerr2 = 0; for (Int_t binx = binx1; binx <= binx2; ++binx) { if (width) dx = fXaxis.GetBinWidth(binx); for (Int_t biny = biny1; biny <= biny2; ++biny) { if (width) dy = fYaxis.GetBinWidth(biny); for (Int_t binz = binz1; binz <= binz2; ++binz) { if (width) dz = fZaxis.GetBinWidth(binz); Int_t bin = GetBin(binx, biny, binz); if (width) integral += GetBinContent(bin)*dx*dy*dz; else integral += GetBinContent(bin); if (doError) { if (width) igerr2 += GetBinError(bin)*GetBinError(bin)*dx*dx*dy*dy*dz*dz; else igerr2 += GetBinError(bin)*GetBinError(bin); } } } } if (doError) error = TMath::Sqrt(igerr2); return integral; } //______________________________________________________________________________ Double_t TH1::AndersonDarlingTest(const TH1 *h2, Option_t *option) const { // Statistical test of compatibility in shape between // this histogram and h2, using the Anderson-Darling 2 sample test. // The AD 2 sample test formula are derived from the paper // F.W Scholz, M.A. Stephens "k-Sample Anderson-Darling Test". // The test is implemented in root in the ROOT::Math::GoFTest class // It is the same formula ( (6) in the paper), and also shown in this preprint // http://arxiv.org/pdf/0804.0380v1.pdf // Binned data are considered as un-binned data // with identical observation happening in the bin center. // // option is a character string to specify options // "D" Put out a line of "Debug" printout // "T" Return the normalized A-D test statistic // // Note1: Underflow and overflow are not considered in the test // Note2: The test works only for un-weighted histogram (i.e. representing counts) // Note3: The histograms are not required to have the same X axis // Note4: The test works only for 1-dimensional histograms Double_t advalue = 0; Double_t pvalue = AndersonDarlingTest(h2, advalue); TString opt = option; opt.ToUpper(); if (opt.Contains("D") ) { printf(" AndersonDarlingTest Prob = %g, AD TestStatistic = %g\n",pvalue,advalue); } if (opt.Contains("T") ) return advalue; return pvalue; } //______________________________________________________________________________ Double_t TH1::AndersonDarlingTest(const TH1 *h2, Double_t & advalue) const { // Same funciton as above but returning also the test statistic value if (GetDimension() != 1 || h2->GetDimension() != 1) { Error("AndersonDarlingTest","Histograms must be 1-D"); return -1; } // use the BinData class ROOT::Fit::BinData data1; ROOT::Fit::BinData data2; ROOT::Fit::FillData(data1, this, 0); ROOT::Fit::FillData(data2, h2, 0); double pvalue; ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2, pvalue,advalue); return pvalue; } //______________________________________________________________________________ Double_t TH1::KolmogorovTest(const TH1 *h2, Option_t *option) const { // Statistical test of compatibility in shape between // this histogram and h2, using Kolmogorov test. // Note that the KolmogorovTest (KS) test should in theory be used only for unbinned data // and not for binned data as in the case of the histogram (see NOTE 3 below). // So, before using this method blindly, read the NOTE 3. // // // Default: Ignore under- and overflow bins in comparison // // option is a character string to specify options // "U" include Underflows in test (also for 2-dim) // "O" include Overflows (also valid for 2-dim) // "N" include comparison of normalizations // "D" Put out a line of "Debug" printout // "M" Return the Maximum Kolmogorov distance instead of prob // "X" Run the pseudo experiments post-processor with the following procedure: // make pseudoexperiments based on random values from the parent // distribution and compare the KS distance of the pseudoexperiment // to the parent distribution. Bin the KS distances in a histogram, // and then take the integral of all the KS values above the value // obtained from the original data to Monte Carlo distribution. // The number of pseudo-experiments nEXPT is currently fixed at 1000. // The function returns the integral. // (thanks to Ben Kilminster to submit this procedure). Note that // this option "X" is much slower. // // The returned function value is the probability of test // (much less than one means NOT compatible) // // Code adapted by Rene Brun from original HBOOK routine HDIFF // // NOTE1 // A good description of the Kolmogorov test can be seen at: // http://www.itl.nist.gov/div898/handbook/eda/section3/eda35g.htm // // NOTE2 // see also alternative function TH1::Chi2Test // The Kolmogorov test is assumed to give better results than Chi2Test // in case of histograms with low statistics. // // NOTE3 (Jan Conrad, Fred James) // "The returned value PROB is calculated such that it will be // uniformly distributed between zero and one for compatible histograms, // provided the data are not binned (or the number of bins is very large // compared with the number of events). Users who have access to unbinned // data and wish exact confidence levels should therefore not put their data // into histograms, but should call directly TMath::KolmogorovTest. On // the other hand, since TH1 is a convenient way of collecting data and // saving space, this function has been provided. However, the values of // PROB for binned data will be shifted slightly higher than expected, // depending on the effects of the binning. For example, when comparing two // uniform distributions of 500 events in 100 bins, the values of PROB, // instead of being exactly uniformly distributed between zero and one, have // a mean value of about 0.56. We can apply a useful // rule: As long as the bin width is small compared with any significant // physical effect (for example the experimental resolution) then the binning // cannot have an important effect. Therefore, we believe that for all // practical purposes, the probability value PROB is calculated correctly // provided the user is aware that: // 1. The value of PROB should not be expected to have exactly the correct // distribution for binned data. // 2. The user is responsible for seeing to it that the bin widths are // small compared with any physical phenomena of interest. // 3. The effect of binning (if any) is always to make the value of PROB // slightly too big. That is, setting an acceptance criterion of (PROB>0.05 // will assure that at most 5% of truly compatible histograms are rejected, // and usually somewhat less." // // Note also that for GoF test of unbinned data ROOT provides also the class // ROOT::Math::GoFTest. The class has also method for doing one sample tests // (i.e. comparing the data with a given distribution). TString opt = option; opt.ToUpper(); Double_t prob = 0; TH1 *h1 = (TH1*)this; if (h2 == 0) return 0; TAxis *axis1 = h1->GetXaxis(); TAxis *axis2 = h2->GetXaxis(); Int_t ncx1 = axis1->GetNbins(); Int_t ncx2 = axis2->GetNbins(); // Check consistency of dimensions if (h1->GetDimension() != 1 || h2->GetDimension() != 1) { Error("KolmogorovTest","Histograms must be 1-D\n"); return 0; } // Check consistency in number of channels if (ncx1 != ncx2) { Error("KolmogorovTest","Number of channels is different, %d and %d\n",ncx1,ncx2); return 0; } // Check consistency in channel edges Double_t difprec = 1e-5; Double_t diff1 = TMath::Abs(axis1->GetXmin() - axis2->GetXmin()); Double_t diff2 = TMath::Abs(axis1->GetXmax() - axis2->GetXmax()); if (diff1 > difprec || diff2 > difprec) { Error("KolmogorovTest","histograms with different binning"); return 0; } Bool_t afunc1 = kFALSE; Bool_t afunc2 = kFALSE; Double_t sum1 = 0, sum2 = 0; Double_t ew1, ew2, w1 = 0, w2 = 0; Int_t bin; Int_t ifirst = 1; Int_t ilast = ncx1; // integral of all bins (use underflow/overflow if option) if (opt.Contains("U")) ifirst = 0; if (opt.Contains("O")) ilast = ncx1 +1; for (bin = ifirst; bin <= ilast; bin++) { sum1 += h1->GetBinContent(bin); sum2 += h2->GetBinContent(bin); ew1 = h1->GetBinError(bin); ew2 = h2->GetBinError(bin); w1 += ew1*ew1; w2 += ew2*ew2; } if (sum1 == 0) { Error("KolmogorovTest","Histogram1 %s integral is zero\n",h1->GetName()); return 0; } if (sum2 == 0) { Error("KolmogorovTest","Histogram2 %s integral is zero\n",h2->GetName()); return 0; } // calculate the effective entries. // the case when errors are zero (w1 == 0 or w2 ==0) are equivalent to // compare to a function. In that case the rescaling is done only on sqrt(esum2) or sqrt(esum1) Double_t esum1 = 0, esum2 = 0; if (w1 > 0) esum1 = sum1 * sum1 / w1; else afunc1 = kTRUE; // use later for calculating z if (w2 > 0) esum2 = sum2 * sum2 / w2; else afunc2 = kTRUE; // use later for calculating z if (afunc2 && afunc1) { Error("KolmogorovTest","Errors are zero for both histograms\n"); return 0; } Double_t s1 = 1/sum1; Double_t s2 = 1/sum2; // Find largest difference for Kolmogorov Test Double_t dfmax =0, rsum1 = 0, rsum2 = 0; for (bin=ifirst;bin<=ilast;bin++) { rsum1 += s1*h1->GetBinContent(bin); rsum2 += s2*h2->GetBinContent(bin); dfmax = TMath::Max(dfmax,TMath::Abs(rsum1-rsum2)); } // Get Kolmogorov probability Double_t z, prb1=0, prb2=0, prb3=0; // case h1 is exact (has zero errors) if (afunc1) z = dfmax*TMath::Sqrt(esum2); // case h2 has zero errors else if (afunc2) z = dfmax*TMath::Sqrt(esum1); else // for comparison between two data sets z = dfmax*TMath::Sqrt(esum1*esum2/(esum1+esum2)); prob = TMath::KolmogorovProb(z); // option N to combine normalization makes sense if both afunc1 and afunc2 are false if (opt.Contains("N") && !(afunc1 || afunc2 ) ) { // Combine probabilities for shape and normalization, prb1 = prob; Double_t d12 = esum1-esum2; Double_t chi2 = d12*d12/(esum1+esum2); prb2 = TMath::Prob(chi2,1); // see Eadie et al., section 11.6.2 if (prob > 0 && prb2 > 0) prob *= prb2*(1-TMath::Log(prob*prb2)); else prob = 0; } // X option. Pseudo-experiments post-processor to determine KS probability const Int_t nEXPT = 1000; if (opt.Contains("X") && !(afunc1 || afunc2 ) ) { Double_t dSEXPT; TH1 *hExpt = (TH1*)(gDirectory ? gDirectory->CloneObject(this,kFALSE) : gROOT->CloneObject(this,kFALSE)); // make nEXPT experiments (this should be a parameter) prb3 = 0; for (Int_t i=0; i < nEXPT; i++) { hExpt->Reset(); hExpt->FillRandom(h1,(Int_t)esum2); dSEXPT = KolmogorovTest(hExpt,"M"); if (dSEXPT>dfmax) prb3 += 1.0; } prb3 /= (Double_t)nEXPT; delete hExpt; } // debug printout if (opt.Contains("D")) { printf(" Kolmo Prob h1 = %s, sum bin content =%g effective entries =%g\n",h1->GetName(),sum1,esum1); printf(" Kolmo Prob h2 = %s, sum bin content =%g effective entries =%g\n",h2->GetName(),sum2,esum2); printf(" Kolmo Prob = %g, Max Dist = %g\n",prob,dfmax); if (opt.Contains("N")) printf(" Kolmo Prob = %f for shape alone, =%f for normalisation alone\n",prb1,prb2); if (opt.Contains("X")) printf(" Kolmo Prob = %f with %d pseudo-experiments\n",prb3,nEXPT); } // This numerical error condition should never occur: if (TMath::Abs(rsum1-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h1=%s\n",h1->GetName()); if (TMath::Abs(rsum2-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h2=%s\n",h2->GetName()); if(opt.Contains("M")) return dfmax; else if(opt.Contains("X")) return prb3; else return prob; } //______________________________________________________________________________ void TH1::SetContent(const Double_t *content) { // -*-*-*-*-*-*Replace bin contents by the contents of array content*-*-*-* // ===================================================== Int_t bin; Double_t bincontent; int nbins = fNcells; // save value because SetBinContent can change fNCells for (bin=0; bin<nbins; bin++) { bincontent = *(content + bin); SetBinContent(bin, bincontent); } } //______________________________________________________________________________ Int_t TH1::GetContour(Double_t *levels) { // Return contour values into array levels if pointer levels is non zero // // The function returns the number of contour levels. // see GetContourLevel to return one contour only // Int_t nlevels = fContour.fN; if (levels) { if (nlevels == 0) { nlevels = 20; SetContour(nlevels); } else { if (TestBit(kUserContour) == 0) SetContour(nlevels); } for (Int_t level=0; level<nlevels; level++) levels[level] = fContour.fArray[level]; } return nlevels; } //______________________________________________________________________________ Double_t TH1::GetContourLevel(Int_t level) const { // Return value of contour number level // see GetContour to return the array of all contour levels if (level <0 || level >= fContour.fN) return 0; Double_t zlevel = fContour.fArray[level]; return zlevel; } //______________________________________________________________________________ Double_t TH1::GetContourLevelPad(Int_t level) const { // Return the value of contour number "level" in Pad coordinates ie: if the Pad // is in log scale along Z it returns le log of the contour level value. // see GetContour to return the array of all contour levels if (level <0 || level >= fContour.fN) return 0; Double_t zlevel = fContour.fArray[level]; // In case of user defined contours and Pad in log scale along Z, // fContour.fArray doesn't contain the log of the contour whereas it does // in case of equidistant contours. if (gPad && gPad->GetLogz() && TestBit(kUserContour)) { if (zlevel <= 0) return 0; zlevel = TMath::Log10(zlevel); } return zlevel; } //______________________________________________________________________________ void TH1::SetBuffer(Int_t buffersize, Option_t * /*option*/) { // set the maximum number of entries to be kept in the buffer if (fBuffer) { BufferEmpty(); delete [] fBuffer; fBuffer = 0; } if (buffersize <= 0) { fBufferSize = 0; return; } if (buffersize < 100) buffersize = 100; fBufferSize = 1 + buffersize*(fDimension+1); fBuffer = new Double_t[fBufferSize]; memset(fBuffer,0,sizeof(Double_t)*fBufferSize); } //______________________________________________________________________________ void TH1::SetContour(Int_t nlevels, const Double_t *levels) { // Set the number and values of contour levels. // // By default the number of contour levels is set to 20. The contours values // in the array "levels" should be specified in increasing order. // // if argument levels = 0 or missing, equidistant contours are computed Int_t level; ResetBit(kUserContour); if (nlevels <=0 ) { fContour.Set(0); return; } fContour.Set(nlevels); // - Contour levels are specified if (levels) { SetBit(kUserContour); for (level=0; level<nlevels; level++) fContour.fArray[level] = levels[level]; } else { // - contour levels are computed automatically as equidistant contours Double_t zmin = GetMinimum(); Double_t zmax = GetMaximum(); if ((zmin == zmax) && (zmin != 0)) { zmax += 0.01*TMath::Abs(zmax); zmin -= 0.01*TMath::Abs(zmin); } Double_t dz = (zmax-zmin)/Double_t(nlevels); if (gPad && gPad->GetLogz()) { if (zmax <= 0) return; if (zmin <= 0) zmin = 0.001*zmax; zmin = TMath::Log10(zmin); zmax = TMath::Log10(zmax); dz = (zmax-zmin)/Double_t(nlevels); } for (level=0; level<nlevels; level++) { fContour.fArray[level] = zmin + dz*Double_t(level); } } } //______________________________________________________________________________ void TH1::SetContourLevel(Int_t level, Double_t value) { // Set value for one contour level. if (level <0 || level >= fContour.fN) return; SetBit(kUserContour); fContour.fArray[level] = value; } //______________________________________________________________________________ Double_t TH1::GetMaximum(Double_t maxval) const { // Return maximum value smaller than maxval of bins in the range, // unless the value has been overridden by TH1::SetMaximum, // in which case it returns that value. (This happens, for example, // when the histogram is drawn and the y or z axis limits are changed // // To get the maximum value of bins in the histogram regardless of // whether the value has been overridden, use // h->GetBinContent(h->GetMaximumBin()) if (fMaximum != -1111) return fMaximum; Int_t bin, binx, biny, binz; Int_t xfirst = fXaxis.GetFirst(); Int_t xlast = fXaxis.GetLast(); Int_t yfirst = fYaxis.GetFirst(); Int_t ylast = fYaxis.GetLast(); Int_t zfirst = fZaxis.GetFirst(); Int_t zlast = fZaxis.GetLast(); Double_t maximum = -FLT_MAX, value; for (binz=zfirst;binz<=zlast;binz++) { for (biny=yfirst;biny<=ylast;biny++) { for (binx=xfirst;binx<=xlast;binx++) { bin = GetBin(binx,biny,binz); value = GetBinContent(bin); if (value > maximum && value < maxval) maximum = value; } } } return maximum; } //______________________________________________________________________________ Int_t TH1::GetMaximumBin() const { // -*-*-*-*-*Return location of bin with maximum value in the range*-* // ====================================================== Int_t locmax, locmay, locmaz; return GetMaximumBin(locmax, locmay, locmaz); } //______________________________________________________________________________ Int_t TH1::GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locmaz) const { // -*-*-*-*-*Return location of bin with maximum value in the range*-* // ====================================================== Int_t bin, binx, biny, binz; Int_t locm; Int_t xfirst = fXaxis.GetFirst(); Int_t xlast = fXaxis.GetLast(); Int_t yfirst = fYaxis.GetFirst(); Int_t ylast = fYaxis.GetLast(); Int_t zfirst = fZaxis.GetFirst(); Int_t zlast = fZaxis.GetLast(); Double_t maximum = -FLT_MAX, value; locm = locmax = locmay = locmaz = 0; for (binz=zfirst;binz<=zlast;binz++) { for (biny=yfirst;biny<=ylast;biny++) { for (binx=xfirst;binx<=xlast;binx++) { bin = GetBin(binx,biny,binz); value = GetBinContent(bin); if (value > maximum) { maximum = value; locm = bin; locmax = binx; locmay = biny; locmaz = binz; } } } } return locm; } //______________________________________________________________________________ Double_t TH1::GetMinimum(Double_t minval) const { // Return minimum value larger than minval of bins in the range, // unless the value has been overridden by TH1::SetMinimum, // in which case it returns that value. (This happens, for example, // when the histogram is drawn and the y or z axis limits are changed // // To get the minimum value of bins in the histogram regardless of // whether the value has been overridden, use // h->GetBinContent(h->GetMinimumBin()) if (fMinimum != -1111) return fMinimum; Int_t bin, binx, biny, binz; Int_t xfirst = fXaxis.GetFirst(); Int_t xlast = fXaxis.GetLast(); Int_t yfirst = fYaxis.GetFirst(); Int_t ylast = fYaxis.GetLast(); Int_t zfirst = fZaxis.GetFirst(); Int_t zlast = fZaxis.GetLast(); Double_t minimum=FLT_MAX, value; for (binz=zfirst;binz<=zlast;binz++) { for (biny=yfirst;biny<=ylast;biny++) { for (binx=xfirst;binx<=xlast;binx++) { bin = GetBin(binx,biny,binz); value = GetBinContent(bin); if (value < minimum && value > minval) minimum = value; } } } return minimum; } //______________________________________________________________________________ Int_t TH1::GetMinimumBin() const { // -*-*-*-*-*Return location of bin with minimum value in the range*-* // ====================================================== Int_t locmix, locmiy, locmiz; return GetMinimumBin(locmix, locmiy, locmiz); } //______________________________________________________________________________ Int_t TH1::GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locmiz) const { // -*-*-*-*-*Return location of bin with minimum value in the range*-* // ====================================================== Int_t bin, binx, biny, binz; Int_t locm; Int_t xfirst = fXaxis.GetFirst(); Int_t xlast = fXaxis.GetLast(); Int_t yfirst = fYaxis.GetFirst(); Int_t ylast = fYaxis.GetLast(); Int_t zfirst = fZaxis.GetFirst(); Int_t zlast = fZaxis.GetLast(); Double_t minimum = FLT_MAX, value; locm = locmix = locmiy = locmiz = 0; for (binz=zfirst;binz<=zlast;binz++) { for (biny=yfirst;biny<=ylast;biny++) { for (binx=xfirst;binx<=xlast;binx++) { bin = GetBin(binx,biny,binz); value = GetBinContent(bin); if (value < minimum) { minimum = value; locm = bin; locmix = binx; locmiy = biny; locmiz = binz; } } } } return locm; } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax) { // -*-*-*-*-*-*-*Redefine x axis parameters*-*-*-*-*-*-*-*-*-*-*-* // =========================== // The X axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange if (GetDimension() != 1) { Error("SetBins","Operation only valid for 1-d histograms"); return; } fXaxis.SetRange(0,0); fXaxis.Set(nx,xmin,xmax); fYaxis.Set(1,0,1); fZaxis.Set(1,0,1); fNcells = nx+2; SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, const Double_t *xBins) { // -*-*-*-*-*-*-*Redefine x axis parameters with variable bin sizes *-*-*-*-*-*-*-*-*-* // =================================================== // The X axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange // xBins is supposed to be of length nx+1 if (GetDimension() != 1) { Error("SetBins","Operation only valid for 1-d histograms"); return; } fXaxis.SetRange(0,0); fXaxis.Set(nx,xBins); fYaxis.Set(1,0,1); fZaxis.Set(1,0,1); fNcells = nx+2; SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax) { // -*-*-*-*-*-*-*Redefine x and y axis parameters*-*-*-*-*-*-*-*-*-*-*-* // ================================= // The X and Y axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange if (GetDimension() != 2) { Error("SetBins","Operation only valid for 2-D histograms"); return; } fXaxis.SetRange(0,0); fYaxis.SetRange(0,0); fXaxis.Set(nx,xmin,xmax); fYaxis.Set(ny,ymin,ymax); fZaxis.Set(1,0,1); fNcells = (nx+2)*(ny+2); SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins) { // -*-*-*-*-*-*-*Redefine x and y axis parameters with variable bin sizes *-*-*-*-*-*-*-*-* // ========================================================= // The X and Y axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange // xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1 if (GetDimension() != 2) { Error("SetBins","Operation only valid for 2-D histograms"); return; } fXaxis.SetRange(0,0); fYaxis.SetRange(0,0); fXaxis.Set(nx,xBins); fYaxis.Set(ny,yBins); fZaxis.Set(1,0,1); fNcells = (nx+2)*(ny+2); SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax, Int_t nz, Double_t zmin, Double_t zmax) { // -*-*-*-*-*-*-*Redefine x, y and z axis parameters*-*-*-*-*-*-*-*-*-*-*-* // ==================================== // The X, Y and Z axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange if (GetDimension() != 3) { Error("SetBins","Operation only valid for 3-D histograms"); return; } fXaxis.SetRange(0,0); fYaxis.SetRange(0,0); fZaxis.SetRange(0,0); fXaxis.Set(nx,xmin,xmax); fYaxis.Set(ny,ymin,ymax); fZaxis.Set(nz,zmin,zmax); fNcells = (nx+2)*(ny+2)*(nz+2); SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins, Int_t nz, const Double_t *zBins) { // -*-*-*-*-*-*-*Redefine x, y and z axis parameters with variable bin sizes *-*-*-*-*-*-*-*-* // ============================================================ // The X, Y and Z axis parameters are modified. // The bins content array is resized // if errors (Sumw2) the errors array is resized // The previous bin contents are lost // To change only the axis limits, see TAxis::SetRange // xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1, // zBins is supposed to be of length nz+1 if (GetDimension() != 3) { Error("SetBins","Operation only valid for 3-D histograms"); return; } fXaxis.SetRange(0,0); fYaxis.SetRange(0,0); fZaxis.SetRange(0,0); fXaxis.Set(nx,xBins); fYaxis.Set(ny,yBins); fZaxis.Set(nz,zBins); fNcells = (nx+2)*(ny+2)*(nz+2); SetBinsLength(fNcells); if (fSumw2.fN) { fSumw2.Set(fNcells); } } //______________________________________________________________________________ void TH1::SetMaximum(Double_t maximum) { // Set the maximum value for the Y axis, in case of 1-D histograms, // or the Z axis in case of 2-D histograms // // By default the maximum value used in drawing is the maximum value of the histogram plus // a margin of 10 per cent. If this function has been called, the value of 'maximum' is // used, with no extra margin. // // TH1::GetMaximum returns the maximum value of the bins in the histogram, unless the // maximum has been set manually by this function or by altering the y/z axis limits. // Use TH1::GetMaximumBin to find the bin with the maximum value of an histogram // fMaximum = maximum; } //______________________________________________________________________________ void TH1::SetMinimum(Double_t minimum) { // Set the minimum value for the Y axis, in case of 1-D histograms, // or the Z axis in case of 2-D histograms // // By default the minimum value used in drawing is the minimum value of the histogram plus // a margin of 10 per cent. If this function has been called, the value of 'minimum' is // used, with no extra margin. // // TH1::GetMinimum returns the minimum value of the bins in the histogram, unless the // minimum has been set manually by this function or by altering the y/z axis limits. // Use TH1::GetMinimumBin to find the bin with the minimum value of an histogram // fMinimum = minimum; } //______________________________________________________________________________ void TH1::SetDirectory(TDirectory *dir) { // By default when an histogram is created, it is added to the list // of histogram objects in the current directory in memory. // Remove reference to this histogram from current directory and add // reference to new directory dir. dir can be 0 in which case the // histogram does not belong to any directory. if (fDirectory == dir) return; if (fDirectory) fDirectory->Remove(this); fDirectory = dir; if (fDirectory) fDirectory->Append(this); } //______________________________________________________________________________ void TH1::SetError(const Double_t *error) { // -*-*-*-*-*-*-*Replace bin errors by values in array error*-*-*-*-*-*-*-*-* // =========================================== Int_t bin; Double_t binerror; for (bin=0; bin<fNcells; bin++) { binerror = error[bin]; SetBinError(bin, binerror); } } //______________________________________________________________________________ void TH1::SetName(const char *name) { // Change the name of this histogram // // Histograms are named objects in a THashList. // We must update the hashlist if we change the name if (fDirectory) fDirectory->Remove(this); fName = name; if (fDirectory) fDirectory->Append(this); } //______________________________________________________________________________ void TH1::SetNameTitle(const char *name, const char *title) { // Change the name and title of this histogram // // Histograms are named objects in a THashList. // We must update the hashlist if we change the name if (fDirectory) fDirectory->Remove(this); fName = name; SetTitle(title); if (fDirectory) fDirectory->Append(this); } //______________________________________________________________________________ void TH1::SetStats(Bool_t stats) { // -*-*-*-*-*-*-*Set statistics option on/off // ============================ // By default, the statistics box is drawn. // The paint options can be selected via gStyle->SetOptStats. // This function sets/resets the kNoStats bin in the histogram object. // It has priority over the Style option. ResetBit(kNoStats); if (!stats) { SetBit(kNoStats); //remove the "stats" object from the list of functions if (fFunctions) { TObject *obj = fFunctions->FindObject("stats"); if (obj) { fFunctions->Remove(obj); delete obj; } } } } //______________________________________________________________________________ void TH1::Sumw2(Bool_t flag) { // Create structure to store sum of squares of weights*-*-*-*-*-*-*-* // // if histogram is already filled, the sum of squares of weights // is filled with the existing bin contents // // The error per bin will be computed as sqrt(sum of squares of weight) // for each bin. // // This function is automatically called when the histogram is created // if the static function TH1::SetDefaultSumw2 has been called before. // If flag = false the structure is deleted if (!flag) { // clear the array if existing - do nothing otherwise if (fSumw2.fN > 0 ) fSumw2.Set(0); return; } if (fSumw2.fN == fNcells) { if (!fgDefaultSumw2 ) Warning("Sumw2","Sum of squares of weights structure already created"); return; } fSumw2.Set(fNcells); if ( fEntries > 0 ) for (Int_t bin=0; bin<fNcells; bin++) { fSumw2.fArray[bin] = TMath::Abs(GetBinContent(bin)); } } //______________________________________________________________________________ TF1 *TH1::GetFunction(const char *name) const { // -*-*-*Return pointer to function with name*-*-*-*-*-*-*-*-*-*-*-*-* // =================================== // // Functions such as TH1::Fit store the fitted function in the list of // functions of this histogram. return (TF1*)fFunctions->FindObject(name); } //______________________________________________________________________________ Double_t TH1::GetBinError(Int_t bin) const { // -*-*-*-*-*Return 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) bin = fNcells-1; if (fBuffer) ((TH1*)this)->BufferEmpty(); if (fSumw2.fN) { Double_t err2 = fSumw2.fArray[bin]; return TMath::Sqrt(err2); } Double_t error2 = TMath::Abs(GetBinContent(bin)); return TMath::Sqrt(error2); } //______________________________________________________________________________ Double_t TH1::GetBinErrorLow(Int_t bin) const { // -*-*-*-*-*Return lower error associated to bin number bin*-*-*-*-* // ================================================== // // The error will depend on the statistic option used will return // the binContent - lower interval value // // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (fBinStatErrOpt == kNormal || fSumw2.fN) return GetBinError(bin); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (fBuffer) ((TH1*)this)->BufferEmpty(); Double_t alpha = 1.- 0.682689492; if (fBinStatErrOpt == kPoisson2) alpha = 0.05; Double_t c = GetBinContent(bin); Int_t n = int(c); if (n < 0) { Warning("GetBinErrorLow","Histogram has negative bin content-force usage to normal errors"); ((TH1*)this)->fBinStatErrOpt = kNormal; return GetBinError(bin); } if (n == 0) return 0; return c - ROOT::Math::gamma_quantile( alpha/2, n, 1.); } //______________________________________________________________________________ Double_t TH1::GetBinErrorUp(Int_t bin) const { // -*-*-*-*-*Return upper error associated to bin number bin*-*-*-*-* // ================================================== // // The error will depend on the statistic option used will return // the binContent - upper interval value // // // -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* if (fBinStatErrOpt == kNormal || fSumw2.fN) return GetBinError(bin); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (fBuffer) ((TH1*)this)->BufferEmpty(); Double_t alpha = 1.- 0.682689492; if (fBinStatErrOpt == kPoisson2) alpha = 0.05; Double_t c = GetBinContent(bin); Int_t n = int(c); if (n < 0) { Warning("GetBinErrorUp","Histogram has negative bin content-force usage to normal errors"); ((TH1*)this)->fBinStatErrOpt = kNormal; return GetBinError(bin); } // for N==0 return an upper limit at 0.68 or (1-alpha)/2 ? // decide to return always (1-alpha)/2 upper interval //if (n == 0) return ROOT::Math::gamma_quantile_c(alpha,n+1,1); return ROOT::Math::gamma_quantile_c( alpha/2, n+1, 1) - c; } //______________________________________________________________________________ Double_t TH1::GetBinError(Int_t binx, Int_t biny) const { // -*-*-*-*-*Return error of bin number binx, biny // ===================================== // NB: Function to be called for 2-D histograms only Int_t bin = GetBin(binx,biny); return GetBinError(bin); } //______________________________________________________________________________ Double_t TH1::GetBinError(Int_t binx, Int_t biny, Int_t binz) const { // -*-*-*-*-*Return error of bin number binx,biny,binz // ========================================= // NB: Function to be called for 3-D histograms only Int_t bin = GetBin(binx,biny,binz); return GetBinError(bin); } //______________________________________________________________________________ Double_t TH1::GetCellContent(Int_t binx, Int_t biny) const { // -*-*-*-*-*Return content of bin number binx, biny // ===================================== // NB: Function to be called for 2-D histograms only Int_t bin = GetBin(binx,biny); return GetBinContent(bin); } //______________________________________________________________________________ Double_t TH1::GetCellError(Int_t binx, Int_t biny) const { // -*-*-*-*-*Return error of bin number binx, biny // ===================================== // NB: Function to be called for 2-D histograms only Int_t bin = GetBin(binx,biny); return GetBinError(bin); } //L.M. These following getters are useless and should be probably deprecated //______________________________________________________________________________ Double_t TH1::GetBinCenter(Int_t bin) const { // return bin center for 1D historam // Better to use h1.GetXaxis().GetBinCenter(bin) if (fDimension == 1) return fXaxis.GetBinCenter(bin); Error("GetBinCenter","Invalid method for a %d-d histogram - return a NaN",fDimension); return TMath::QuietNaN(); } //______________________________________________________________________________ Double_t TH1::GetBinLowEdge(Int_t bin) const { // return bin lower edge for 1D historam // Better to use h1.GetXaxis().GetBinLowEdge(bin) if (fDimension == 1) return fXaxis.GetBinLowEdge(bin); Error("GetBinLowEdge","Invalid method for a %d-d histogram - return a NaN",fDimension); return TMath::QuietNaN(); } //______________________________________________________________________________ Double_t TH1::GetBinWidth(Int_t bin) const { // return bin width for 1D historam // Better to use h1.GetXaxis().GetBinWidth(bin) if (fDimension == 1) return fXaxis.GetBinWidth(bin); Error("GetBinWidth","Invalid method for a %d-d histogram - return a NaN",fDimension); return TMath::QuietNaN(); } //______________________________________________________________________________ void TH1::GetCenter(Double_t *center) const { // Fill array with center of bins for 1D histogram // Better to use h1.GetXaxis().GetCenter(center) if (fDimension == 1) { fXaxis.GetCenter(center); return; } Error("GetCenter","Invalid method for a %d-d histogram ",fDimension); } //______________________________________________________________________________ void TH1::GetLowEdge(Double_t *edge) const { // Fill array with low edge of bins for 1D histogram // Better to use h1.GetXaxis().GetLowEdge(edge) if (fDimension == 1) { fXaxis.GetLowEdge(edge); return; } Error("GetLowEdge","Invalid method for a %d-d histogram ",fDimension); } //______________________________________________________________________________ void TH1::SetBinError(Int_t bin, Double_t error) { // see convention for numbering bins in TH1::GetBin if (!fSumw2.fN) Sumw2(); if (bin <0 || bin>= fSumw2.fN) return; fSumw2.fArray[bin] = error*error; } //______________________________________________________________________________ void TH1::SetBinContent(Int_t binx, Int_t biny, Double_t content) { // see convention for numbering bins in TH1::GetBin if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; Int_t bin = GetBin(binx,biny); SetBinContent(bin,content); } //______________________________________________________________________________ void TH1::SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content) { // see convention for numbering bins in TH1::GetBin if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; if (binz <0 || binz>fZaxis.GetNbins()+1) return; Int_t bin = GetBin(binx,biny,binz); SetBinContent(bin,content); } //______________________________________________________________________________ void TH1::SetCellContent(Int_t binx, Int_t biny, Double_t content) { // Set cell content. if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; Int_t bin = GetBin(binx,biny); SetBinContent(bin,content); } //______________________________________________________________________________ void TH1::SetBinError(Int_t binx, Int_t biny, Double_t error) { // see convention for numbering bins in TH1::GetBin if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; Int_t bin = GetBin(binx,biny); SetBinError(bin,error); } //______________________________________________________________________________ void TH1::SetBinError(Int_t binx, Int_t biny, Int_t binz, Double_t error) { // see convention for numbering bins in TH1::GetBin if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; if (binz <0 || binz>fZaxis.GetNbins()+1) return; Int_t bin = GetBin(binx,biny,binz); SetBinError(bin,error); } //______________________________________________________________________________ void TH1::SetCellError(Int_t binx, Int_t biny, Double_t error) { // see convention for numbering bins in TH1::GetBin if (binx <0 || binx>fXaxis.GetNbins()+1) return; if (biny <0 || biny>fYaxis.GetNbins()+1) return; if (!fSumw2.fN) Sumw2(); Int_t bin = biny*(fXaxis.GetNbins()+2) + binx; fSumw2.fArray[bin] = error*error; } //______________________________________________________________________________ void TH1::SetBinContent(Int_t, Double_t) { // see convention for numbering bins in TH1::GetBin AbstractMethod("SetBinContent"); } //______________________________________________________________________________ TH1 *TH1::ShowBackground(Int_t niter, Option_t *option) { // This function calculates the background spectrum in this histogram. // The background is returned as a histogram. // // Function parameters: // -niter, number of iterations (default value = 2) // Increasing niter make the result smoother and lower. // -option: may contain one of the following options // - to set the direction parameter // "BackDecreasingWindow". By default the direction is BackIncreasingWindow // - filterOrder-order of clipping filter, (default "BackOrder2" // -possible values= "BackOrder4" // "BackOrder6" // "BackOrder8" // - "nosmoothing"- if selected, the background is not smoothed // By default the background is smoothed. // - smoothWindow-width of smoothing window, (default is "BackSmoothing3") // -possible values= "BackSmoothing5" // "BackSmoothing7" // "BackSmoothing9" // "BackSmoothing11" // "BackSmoothing13" // "BackSmoothing15" // - "nocompton"- if selected the estimation of Compton edge // will be not be included (by default the compton estimation is set) // - "same" : if this option is specified, the resulting background // histogram is superimposed on the picture in the current pad. // This option is given by default. // // NOTE that the background is only evaluated in the current range of this histogram. // i.e., if this has a bin range (set via h->GetXaxis()->SetRange(binmin, binmax), // the returned histogram will be created with the same number of bins // as this input histogram, but only bins from binmin to binmax will be filled // with the estimated background. // return (TH1*)gROOT->ProcessLineFast(Form("TSpectrum::StaticBackground((TH1*)0x%lx,%d,\"%s\")", (ULong_t)this, niter, option)); } //______________________________________________________________________________ Int_t TH1::ShowPeaks(Double_t sigma, Option_t *option, Double_t threshold) { //Interface to TSpectrum::Search. //The function finds peaks in this histogram where the width is > sigma //and the peak maximum greater than threshold*maximum bin content of this. //For more details see TSpectrum::Search. //Note the difference in the default value for option compared to TSpectrum::Search //option="" by default (instead of "goff"). return (Int_t)gROOT->ProcessLineFast(Form("TSpectrum::StaticSearch((TH1*)0x%lx,%g,\"%s\",%g)", (ULong_t)this, sigma, option, threshold)); } //______________________________________________________________________________ TH1* TH1::TransformHisto(TVirtualFFT *fft, TH1* h_output, Option_t *option) { //For a given transform (first parameter), fills the histogram (second parameter) //with the transform output data, specified in the third parameter //If the 2nd parameter h_output is empty, a new histogram (TH1D or TH2D) is created //and the user is responsible for deleting it. // Available options: // "RE" - real part of the output // "IM" - imaginary part of the output // "MAG" - magnitude of the output // "PH" - phase of the output if (!fft || !fft->GetN() ) { ::Error("TransformHisto","Invalid FFT transform class"); return 0; } if (fft->GetNdim()>2){ ::Error("TransformHisto","Only 1d and 2D transform are supported"); return 0; } Int_t binx,biny; TString opt = option; opt.ToUpper(); Int_t *n = fft->GetN(); TH1 *hout=0; if (h_output) { hout = h_output; } else { TString name = TString::Format("out_%s", opt.Data()); if (fft->GetNdim()==1) hout = new TH1D(name, name,n[0], 0, n[0]); else if (fft->GetNdim()==2) hout = new TH2D(name, name, n[0], 0, n[0], n[1], 0, n[1]); } R__ASSERT(hout != 0); TString type=fft->GetType(); Int_t ind[2]; if (opt.Contains("RE")){ if (type.Contains("2C") || type.Contains("2HC")) { Double_t re, im; for (binx = 1; binx<=hout->GetNbinsX(); binx++) { for (biny=1; biny<=hout->GetNbinsY(); biny++) { ind[0] = binx-1; ind[1] = biny-1; fft->GetPointComplex(ind, re, im); hout->SetBinContent(binx, biny, re); } } } else { for (binx = 1; binx<=hout->GetNbinsX(); binx++) { for (biny=1; biny<=hout->GetNbinsY(); biny++) { ind[0] = binx-1; ind[1] = biny-1; hout->SetBinContent(binx, biny, fft->GetPointReal(ind)); } } } } if (opt.Contains("IM")) { if (type.Contains("2C") || type.Contains("2HC")) { Double_t re, im; for (binx = 1; binx<=hout->GetNbinsX(); binx++) { for (biny=1; biny<=hout->GetNbinsY(); biny++) { ind[0] = binx-1; ind[1] = biny-1; fft->GetPointComplex(ind, re, im); hout->SetBinContent(binx, biny, im); } } } else { ::Error("TransformHisto","No complex numbers in the output"); return 0; } } if (opt.Contains("MA")) { if (type.Contains("2C") || type.Contains("2HC")) { Double_t re, im; for (binx = 1; binx<=hout->GetNbinsX(); binx++) { for (biny=1; biny<=hout->GetNbinsY(); biny++) { ind[0] = binx-1; ind[1] = biny-1; fft->GetPointComplex(ind, re, im); hout->SetBinContent(binx, biny, TMath::Sqrt(re*re + im*im)); } } } else { for (binx = 1; binx<=hout->GetNbinsX(); binx++) { for (biny=1; biny<=hout->GetNbinsY(); biny++) { ind[0] = binx-1; ind[1] = biny-1; hout->SetBinContent(binx, biny, TMath::Abs(fft->GetPointReal(ind))); } } } } if (opt.Contains("PH")) { if (type.Contains("2C") || type.Contains("2HC")){ Double_t re, im, ph; for (binx = 1; binx<=hout->GetNbinsX(); binx++){ for (biny=1; biny<=hout->GetNbinsY(); biny++){ ind[0] = binx-1; ind[1] = biny-1; fft->GetPointComplex(ind, re, im); if (TMath::Abs(re) > 1e-13){ ph = TMath::ATan(im/re); //find the correct quadrant if (re<0 && im<0) ph -= TMath::Pi(); if (re<0 && im>=0) ph += TMath::Pi(); } else { if (TMath::Abs(im) < 1e-13) ph = 0; else if (im>0) ph = TMath::Pi()*0.5; else ph = -TMath::Pi()*0.5; } hout->SetBinContent(binx, biny, ph); } } } else { printf("Pure real output, no phase"); return 0; } } return hout; } //______________________________________________________________________________ // TH1C methods // TH1C : histograms with one byte per channel. Maximum bin content = 127 //______________________________________________________________________________ ClassImp(TH1C) //______________________________________________________________________________ TH1C::TH1C(): TH1(), TArrayC() { // Constructor. fDimension = 1; SetBinsLength(3); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1C::TH1C(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) : TH1(name,title,nbins,xlow,xup) { // // Create a 1-Dim histogram with fix bins of type char (one byte per channel) // ========================================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayC::Set(fNcells); if (xlow >= xup) SetBuffer(fgBufferSize); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Float_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type char (one byte per channel) // ========================================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayC::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Double_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type char (one byte per channel) // ========================================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayC::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1C::~TH1C() { // Destructor. } //______________________________________________________________________________ TH1C::TH1C(const TH1C &h1c) : TH1(), TArrayC() { // Copy constructor. ((TH1C&)h1c).Copy(*this); } //______________________________________________________________________________ void TH1C::AddBinContent(Int_t bin) { // -*-*-*-*-*-*-*-*Increment bin content by 1*-*-*-*-*-*-*-*-*-*-*-*-*-* // ========================== if (fArray[bin] < 127) fArray[bin]++; } //______________________________________________________________________________ void TH1C::AddBinContent(Int_t bin, Double_t w) { // -*-*-*-*-*-*-*-*Increment bin content by w*-*-*-*-*-*-*-*-*-*-*-*-*-* // ========================== Int_t newval = fArray[bin] + Int_t(w); if (newval > -128 && newval < 128) {fArray[bin] = Char_t(newval); return;} if (newval < -127) fArray[bin] = -127; if (newval > 127) fArray[bin] = 127; } //______________________________________________________________________________ void TH1C::Copy(TObject &newth1) const { // Copy this to newth1 TH1::Copy(newth1); } //______________________________________________________________________________ TH1 *TH1C::DrawCopy(Option_t *option) const { // Draw copy. TString opt = option; opt.ToLower(); if (gPad && !opt.Contains("same")) gPad->Clear(); TH1C *newth1 = (TH1C*)Clone(); newth1->SetDirectory(0); newth1->SetBit(kCanDelete); newth1->AppendPad(option); return newth1; } //______________________________________________________________________________ Double_t TH1C::GetBinContent(Int_t bin) const { // see convention for numbering bins in TH1::GetBin if (fBuffer) ((TH1C*)this)->BufferEmpty(); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (!fArray) return 0; return Double_t (fArray[bin]); } //______________________________________________________________________________ void TH1C::Reset(Option_t *option) { // Reset. TH1::Reset(option); TArrayC::Reset(); } //______________________________________________________________________________ void TH1C::SetBinContent(Int_t bin, Double_t content) { // Set bin content // see convention for numbering bins in TH1::GetBin // In case the bin number is greater than the number of bins and // the timedisplay option is set or the kCanRebin bit is set, // the number of bins is automatically doubled to accommodate the new bin fEntries++; fTsumw = 0; if (bin < 0) return; if (bin >= fNcells-1) { if (fXaxis.GetTimeDisplay()) { while (bin >= fNcells-1) LabelsInflate(); } else { if (!TestBit(kCanRebin)) { if (bin == fNcells-1) fArray[bin] = Char_t (content); return; } while (bin >= fNcells-1) LabelsInflate(); } } fArray[bin] = Char_t (content); } //______________________________________________________________________________ void TH1C::SetBinsLength(Int_t n) { // Set total number of bins including under/overflow // Reallocate bin contents array if (n < 0) n = fXaxis.GetNbins() + 2; fNcells = n; TArrayC::Set(n); } //______________________________________________________________________________ TH1C& TH1C::operator=(const TH1C &h1) { // Operator = if (this != &h1) ((TH1C&)h1).Copy(*this); return *this; } //______________________________________________________________________________ TH1C operator*(Double_t c1, const TH1C &h1) { // Operator * TH1C hnew = h1; hnew.Scale(c1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1C operator+(const TH1C &h1, const TH1C &h2) { // Operator + TH1C hnew = h1; hnew.Add(&h2,1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1C operator-(const TH1C &h1, const TH1C &h2) { // Operator - TH1C hnew = h1; hnew.Add(&h2,-1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1C operator*(const TH1C &h1, const TH1C &h2) { // Operator * TH1C hnew = h1; hnew.Multiply(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1C operator/(const TH1C &h1, const TH1C &h2) { // Operator / TH1C hnew = h1; hnew.Divide(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ // TH1S methods // TH1S : histograms with one short per channel. Maximum bin content = 32767 //______________________________________________________________________________ ClassImp(TH1S) //______________________________________________________________________________ TH1S::TH1S(): TH1(), TArrayS() { // Constructor. fDimension = 1; SetBinsLength(3); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1S::TH1S(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) : TH1(name,title,nbins,xlow,xup) { // // Create a 1-Dim histogram with fix bins of type short // ==================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayS::Set(fNcells); if (xlow >= xup) SetBuffer(fgBufferSize); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Float_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type short // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayS::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Double_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type short // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayS::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1S::~TH1S() { // Destructor. } //______________________________________________________________________________ TH1S::TH1S(const TH1S &h1s) : TH1(), TArrayS() { // Copy constructor. ((TH1S&)h1s).Copy(*this); } //______________________________________________________________________________ void TH1S::AddBinContent(Int_t bin) { // -*-*-*-*-*-*-*-*Increment bin content by 1*-*-*-*-*-*-*-*-*-*-*-*-*-* // ========================== if (fArray[bin] < 32767) fArray[bin]++; } //______________________________________________________________________________ void TH1S::AddBinContent(Int_t bin, Double_t w) { // Increment bin content by w // ========================== Int_t newval = fArray[bin] + Int_t(w); if (newval > -32768 && newval < 32768) {fArray[bin] = Short_t(newval); return;} if (newval < -32767) fArray[bin] = -32767; if (newval > 32767) fArray[bin] = 32767; } //______________________________________________________________________________ void TH1S::Copy(TObject &newth1) const { // Copy this to newth1 TH1::Copy(newth1); } //______________________________________________________________________________ TH1 *TH1S::DrawCopy(Option_t *option) const { // Draw copy. TString opt = option; opt.ToLower(); if (gPad && !opt.Contains("same")) gPad->Clear(); TH1S *newth1 = (TH1S*)Clone(); newth1->SetDirectory(0); newth1->SetBit(kCanDelete); newth1->AppendPad(option); return newth1; } //______________________________________________________________________________ Double_t TH1S::GetBinContent(Int_t bin) const { // see convention for numbering bins in TH1::GetBin if (fBuffer) ((TH1S*)this)->BufferEmpty(); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (!fArray) return 0; return Double_t (fArray[bin]); } //______________________________________________________________________________ void TH1S::Reset(Option_t *option) { // Reset. TH1::Reset(option); TArrayS::Reset(); } //______________________________________________________________________________ void TH1S::SetBinContent(Int_t bin, Double_t content) { // Set bin content // see convention for numbering bins in TH1::GetBin // In case the bin number is greater than the number of bins and // the timedisplay option is set or the kCanRebin bit is set, // the number of bins is automatically doubled to accommodate the new bin fEntries++; fTsumw = 0; if (bin < 0) return; if (bin >= fNcells-1) { if (fXaxis.GetTimeDisplay()) { while (bin >= fNcells-1) LabelsInflate(); } else { if (!TestBit(kCanRebin)) { if (bin == fNcells-1) fArray[bin] = Short_t (content); return; } while (bin >= fNcells-1) LabelsInflate(); } } fArray[bin] = Short_t (content); } //______________________________________________________________________________ void TH1S::SetBinsLength(Int_t n) { // Set total number of bins including under/overflow // Reallocate bin contents array if (n < 0) n = fXaxis.GetNbins() + 2; fNcells = n; TArrayS::Set(n); } //______________________________________________________________________________ TH1S& TH1S::operator=(const TH1S &h1) { // Operator = if (this != &h1) ((TH1S&)h1).Copy(*this); return *this; } //______________________________________________________________________________ TH1S operator*(Double_t c1, const TH1S &h1) { // Operator * TH1S hnew = h1; hnew.Scale(c1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1S operator+(const TH1S &h1, const TH1S &h2) { // Operator + TH1S hnew = h1; hnew.Add(&h2,1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1S operator-(const TH1S &h1, const TH1S &h2) { // Operator - TH1S hnew = h1; hnew.Add(&h2,-1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1S operator*(const TH1S &h1, const TH1S &h2) { // Operator * TH1S hnew = h1; hnew.Multiply(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1S operator/(const TH1S &h1, const TH1S &h2) { // Operator / TH1S hnew = h1; hnew.Divide(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ // TH1I methods // TH1I : histograms with one int per channel. Maximum bin content = 2147483647 //______________________________________________________________________________ ClassImp(TH1I) //______________________________________________________________________________ TH1I::TH1I(): TH1(), TArrayI() { // Constructor. fDimension = 1; SetBinsLength(3); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1I::TH1I(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) : TH1(name,title,nbins,xlow,xup) { // // Create a 1-Dim histogram with fix bins of type integer // ==================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayI::Set(fNcells); if (xlow >= xup) SetBuffer(fgBufferSize); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Float_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type integer // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayI::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Double_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type integer // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayI::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1I::~TH1I() { // Destructor. } //______________________________________________________________________________ TH1I::TH1I(const TH1I &h1i) : TH1(), TArrayI() { // Copy constructor. ((TH1I&)h1i).Copy(*this); } //______________________________________________________________________________ void TH1I::AddBinContent(Int_t bin) { // -*-*-*-*-*-*-*-*Increment bin content by 1*-*-*-*-*-*-*-*-*-*-*-*-*-* // ========================== if (fArray[bin] < 2147483647) fArray[bin]++; } //______________________________________________________________________________ void TH1I::AddBinContent(Int_t bin, Double_t w) { // Increment bin content by w // ========================== Int_t newval = fArray[bin] + Int_t(w); if (newval > -2147483647 && newval < 2147483647) {fArray[bin] = Int_t(newval); return;} if (newval < -2147483647) fArray[bin] = -2147483647; if (newval > 2147483647) fArray[bin] = 2147483647; } //______________________________________________________________________________ void TH1I::Copy(TObject &newth1) const { // Copy this to newth1 TH1::Copy(newth1); } //______________________________________________________________________________ TH1 *TH1I::DrawCopy(Option_t *option) const { // Draw copy. TString opt = option; opt.ToLower(); if (gPad && !opt.Contains("same")) gPad->Clear(); TH1I *newth1 = (TH1I*)Clone(); newth1->SetDirectory(0); newth1->SetBit(kCanDelete); newth1->AppendPad(option); return newth1; } //______________________________________________________________________________ Double_t TH1I::GetBinContent(Int_t bin) const { // see convention for numbering bins in TH1::GetBin if (fBuffer) ((TH1I*)this)->BufferEmpty(); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (!fArray) return 0; return Double_t (fArray[bin]); } //______________________________________________________________________________ void TH1I::Reset(Option_t *option) { // Reset. TH1::Reset(option); TArrayI::Reset(); } //______________________________________________________________________________ void TH1I::SetBinContent(Int_t bin, Double_t content) { // Set bin content // see convention for numbering bins in TH1::GetBin // In case the bin number is greater than the number of bins and // the timedisplay option is set or the kCanRebin bit is set, // the number of bins is automatically doubled to accommodate the new bin fEntries++; fTsumw = 0; if (bin < 0) return; if (bin >= fNcells-1) { if (fXaxis.GetTimeDisplay()) { while (bin >= fNcells-1) LabelsInflate(); } else { if (!TestBit(kCanRebin)) { if (bin == fNcells-1) fArray[bin] = Int_t (content); return; } while (bin >= fNcells-1) LabelsInflate(); } } fArray[bin] = Int_t (content); } //______________________________________________________________________________ void TH1I::SetBinsLength(Int_t n) { // Set total number of bins including under/overflow // Reallocate bin contents array if (n < 0) n = fXaxis.GetNbins() + 2; fNcells = n; TArrayI::Set(n); } //______________________________________________________________________________ TH1I& TH1I::operator=(const TH1I &h1) { // Operator = if (this != &h1) ((TH1I&)h1).Copy(*this); return *this; } //______________________________________________________________________________ TH1I operator*(Double_t c1, const TH1I &h1) { // Operator * TH1I hnew = h1; hnew.Scale(c1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1I operator+(const TH1I &h1, const TH1I &h2) { // Operator + TH1I hnew = h1; hnew.Add(&h2,1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1I operator-(const TH1I &h1, const TH1I &h2) { // Operator - TH1I hnew = h1; hnew.Add(&h2,-1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1I operator*(const TH1I &h1, const TH1I &h2) { // Operator * TH1I hnew = h1; hnew.Multiply(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1I operator/(const TH1I &h1, const TH1I &h2) { // Operator / TH1I hnew = h1; hnew.Divide(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ // TH1F methods // TH1F : histograms with one float per channel. Maximum precision 7 digits //______________________________________________________________________________ ClassImp(TH1F) //______________________________________________________________________________ TH1F::TH1F(): TH1(), TArrayF() { // Constructor. fDimension = 1; SetBinsLength(3); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1F::TH1F(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) : TH1(name,title,nbins,xlow,xup) { // // Create a 1-Dim histogram with fix bins of type float // ==================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayF::Set(fNcells); if (xlow >= xup) SetBuffer(fgBufferSize); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Float_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type float // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayF::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Double_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type float // ========================================================= // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayF::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1F::TH1F(const TVectorF &v) : TH1("TVectorF","",v.GetNrows(),0,v.GetNrows()) { // Create a histogram from a TVectorF // by default the histogram name is "TVectorF" and title = "" TArrayF::Set(fNcells); fDimension = 1; Int_t ivlow = v.GetLwb(); for (Int_t i=0;i<fNcells-2;i++) { SetBinContent(i+1,v(i+ivlow)); } TArrayF::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1F::TH1F(const TH1F &h) : TH1(), TArrayF() { // Copy Constructor. ((TH1F&)h).Copy(*this); } //______________________________________________________________________________ TH1F::~TH1F() { // Destructor. } //______________________________________________________________________________ void TH1F::Copy(TObject &newth1) const { // Copy this to newth1. TH1::Copy(newth1); } //______________________________________________________________________________ TH1 *TH1F::DrawCopy(Option_t *option) const { // Draw copy. TString opt = option; opt.ToLower(); if (gPad && !opt.Contains("same")) gPad->Clear(); TH1F *newth1 = (TH1F*)Clone(); newth1->SetDirectory(0); newth1->SetBit(kCanDelete); newth1->AppendPad(option); return newth1; } //______________________________________________________________________________ Double_t TH1F::GetBinContent(Int_t bin) const { // see convention for numbering bins in TH1::GetBin if (fBuffer) ((TH1F*)this)->BufferEmpty(); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (!fArray) return 0; return Double_t (fArray[bin]); } //______________________________________________________________________________ void TH1F::Reset(Option_t *option) { // Reset. TH1::Reset(option); TArrayF::Reset(); } //______________________________________________________________________________ void TH1F::SetBinContent(Int_t bin, Double_t content) { // Set bin content // see convention for numbering bins in TH1::GetBin // In case the bin number is greater than the number of bins and // the timedisplay option is set or the kCanRebin bit is set, // the number of bins is automatically doubled to accommodate the new bin fEntries++; fTsumw = 0; if (bin < 0) return; if (bin >= fNcells-1) { if (fXaxis.GetTimeDisplay()) { while (bin >= fNcells-1) LabelsInflate(); } else { if (!TestBit(kCanRebin)) { if (bin == fNcells-1) fArray[bin] = Float_t (content); return; } while (bin >= fNcells-1) LabelsInflate(); } } fArray[bin] = Float_t (content); } //______________________________________________________________________________ void TH1F::SetBinsLength(Int_t n) { // Set total number of bins including under/overflow // Reallocate bin contents array if (n < 0) n = fXaxis.GetNbins() + 2; fNcells = n; TArrayF::Set(n); } //______________________________________________________________________________ TH1F& TH1F::operator=(const TH1F &h1) { // Operator = if (this != &h1) ((TH1F&)h1).Copy(*this); return *this; } //______________________________________________________________________________ TH1F operator*(Double_t c1, const TH1F &h1) { // Operator * TH1F hnew = h1; hnew.Scale(c1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1F operator+(const TH1F &h1, const TH1F &h2) { // Operator + TH1F hnew = h1; hnew.Add(&h2,1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1F operator-(const TH1F &h1, const TH1F &h2) { // Operator - TH1F hnew = h1; hnew.Add(&h2,-1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1F operator*(const TH1F &h1, const TH1F &h2) { // Operator * TH1F hnew = h1; hnew.Multiply(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1F operator/(const TH1F &h1, const TH1F &h2) { // Operator / TH1F hnew = h1; hnew.Divide(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ // TH1D methods // TH1D : histograms with one double per channel. Maximum precision 14 digits //______________________________________________________________________________ ClassImp(TH1D) //______________________________________________________________________________ TH1D::TH1D(): TH1(), TArrayD() { // Constructor. fDimension = 1; SetBinsLength(3); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1D::TH1D(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup) : TH1(name,title,nbins,xlow,xup) { // // Create a 1-Dim histogram with fix bins of type double // ===================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayD::Set(fNcells); if (xlow >= xup) SetBuffer(fgBufferSize); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Float_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type double // ===================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayD::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Double_t *xbins) : TH1(name,title,nbins,xbins) { // // Create a 1-Dim histogram with variable bins of type double // ===================================================== // (see TH1::TH1 for explanation of parameters) // fDimension = 1; TArrayD::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1D::TH1D(const TVectorD &v) : TH1("TVectorD","",v.GetNrows(),0,v.GetNrows()) { // Create a histogram from a TVectorD // by default the histogram name is "TVectorD" and title = "" TArrayD::Set(fNcells); fDimension = 1; Int_t ivlow = v.GetLwb(); for (Int_t i=0;i<fNcells-2;i++) { SetBinContent(i+1,v(i+ivlow)); } TArrayD::Set(fNcells); if (fgDefaultSumw2) Sumw2(); } //______________________________________________________________________________ TH1D::~TH1D() { // Destructor. } //______________________________________________________________________________ TH1D::TH1D(const TH1D &h1d) : TH1(), TArrayD() { // Constructor. ((TH1D&)h1d).Copy(*this); } //______________________________________________________________________________ void TH1D::Copy(TObject &newth1) const { // Copy this to newth1 TH1::Copy(newth1); } //______________________________________________________________________________ TH1 *TH1D::DrawCopy(Option_t *option) const { // Draw copy. TString opt = option; opt.ToLower(); if (gPad && !opt.Contains("same")) gPad->Clear(); TH1D *newth1 = (TH1D*)Clone(); newth1->SetDirectory(0); newth1->SetBit(kCanDelete); newth1->AppendPad(option); return newth1; } //______________________________________________________________________________ Double_t TH1D::GetBinContent(Int_t bin) const { // see convention for numbering bins in TH1::GetBin if (fBuffer) ((TH1D*)this)->BufferEmpty(); if (bin < 0) bin = 0; if (bin >= fNcells) bin = fNcells-1; if (!fArray) return 0; return Double_t (fArray[bin]); } //______________________________________________________________________________ void TH1D::Reset(Option_t *option) { // Reset. TH1::Reset(option); TArrayD::Reset(); } //______________________________________________________________________________ void TH1D::SetBinContent(Int_t bin, Double_t content) { // Set bin content // see convention for numbering bins in TH1::GetBin // In case the bin number is greater than the number of bins and // the timedisplay option is set or the kCanRebin bit is set, // the number of bins is automatically doubled to accommodate the new bin fEntries++; fTsumw = 0; if (bin < 0) return; if (bin >= fNcells-1) { if (fXaxis.GetTimeDisplay()) { while (bin >= fNcells-1) LabelsInflate(); } else { if (!TestBit(kCanRebin)) { if (bin == fNcells-1) fArray[bin] = content; return; } while (bin >= fNcells-1) LabelsInflate(); } } fArray[bin] = content; } //______________________________________________________________________________ void TH1D::SetBinsLength(Int_t n) { // Set total number of bins including under/overflow // Reallocate bin contents array if (n < 0) n = fXaxis.GetNbins() + 2; fNcells = n; TArrayD::Set(n); } //______________________________________________________________________________ TH1D& TH1D::operator=(const TH1D &h1) { // Operator = if (this != &h1) ((TH1D&)h1).Copy(*this); return *this; } //______________________________________________________________________________ TH1D operator*(Double_t c1, const TH1D &h1) { // Operator * TH1D hnew = h1; hnew.Scale(c1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1D operator+(const TH1D &h1, const TH1D &h2) { // Operator + TH1D hnew = h1; hnew.Add(&h2,1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1D operator-(const TH1D &h1, const TH1D &h2) { // Operator - TH1D hnew = h1; hnew.Add(&h2,-1); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1D operator*(const TH1D &h1, const TH1D &h2) { // Operator * TH1D hnew = h1; hnew.Multiply(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1D operator/(const TH1D &h1, const TH1D &h2) { // Operator / TH1D hnew = h1; hnew.Divide(&h2); hnew.SetDirectory(0); return hnew; } //______________________________________________________________________________ TH1 *R__H(Int_t hid) { //return pointer to histogram with name // hid if id >=0 // h_id if id <0 TString hname; if(hid >= 0) hname.Form("h%d",hid); else hname.Form("h_%d",hid); return (TH1*)gDirectory->Get(hname); } //______________________________________________________________________________ TH1 *R__H(const char * hname) { //return pointer to histogram with name hname return (TH1*)gDirectory->Get(hname); }
TH1.cxx:1
TH1.cxx:2
TH1.cxx:3
TH1.cxx:4
TH1.cxx:5
TH1.cxx:6
TH1.cxx:7
TH1.cxx:8
TH1.cxx:9
TH1.cxx:10
TH1.cxx:11
TH1.cxx:12
TH1.cxx:13
TH1.cxx:14
TH1.cxx:15
TH1.cxx:16
TH1.cxx:17
TH1.cxx:18
TH1.cxx:19
TH1.cxx:20
TH1.cxx:21
TH1.cxx:22
TH1.cxx:23
TH1.cxx:24
TH1.cxx:25
TH1.cxx:26
TH1.cxx:27
TH1.cxx:28
TH1.cxx:29
TH1.cxx:30
TH1.cxx:31
TH1.cxx:32
TH1.cxx:33
TH1.cxx:34
TH1.cxx:35
TH1.cxx:36
TH1.cxx:37
TH1.cxx:38
TH1.cxx:39
TH1.cxx:40
TH1.cxx:41
TH1.cxx:42
TH1.cxx:43
TH1.cxx:44
TH1.cxx:45
TH1.cxx:46
TH1.cxx:47
TH1.cxx:48
TH1.cxx:49
TH1.cxx:50
TH1.cxx:51
TH1.cxx:52
TH1.cxx:53
TH1.cxx:54
TH1.cxx:55
TH1.cxx:56
TH1.cxx:57
TH1.cxx:58
TH1.cxx:59
TH1.cxx:60
TH1.cxx:61
TH1.cxx:62
TH1.cxx:63
TH1.cxx:64
TH1.cxx:65
TH1.cxx:66
TH1.cxx:67
TH1.cxx:68
TH1.cxx:69
TH1.cxx:70
TH1.cxx:71
TH1.cxx:72
TH1.cxx:73
TH1.cxx:74
TH1.cxx:75
TH1.cxx:76
TH1.cxx:77
TH1.cxx:78
TH1.cxx:79
TH1.cxx:80
TH1.cxx:81
TH1.cxx:82
TH1.cxx:83
TH1.cxx:84
TH1.cxx:85
TH1.cxx:86
TH1.cxx:87
TH1.cxx:88
TH1.cxx:89
TH1.cxx:90
TH1.cxx:91
TH1.cxx:92
TH1.cxx:93
TH1.cxx:94
TH1.cxx:95
TH1.cxx:96
TH1.cxx:97
TH1.cxx:98
TH1.cxx:99
TH1.cxx:100
TH1.cxx:101
TH1.cxx:102
TH1.cxx:103
TH1.cxx:104
TH1.cxx:105
TH1.cxx:106
TH1.cxx:107
TH1.cxx:108
TH1.cxx:109
TH1.cxx:110
TH1.cxx:111
TH1.cxx:112
TH1.cxx:113
TH1.cxx:114
TH1.cxx:115
TH1.cxx:116
TH1.cxx:117
TH1.cxx:118
TH1.cxx:119
TH1.cxx:120
TH1.cxx:121
TH1.cxx:122
TH1.cxx:123
TH1.cxx:124
TH1.cxx:125
TH1.cxx:126
TH1.cxx:127
TH1.cxx:128
TH1.cxx:129
TH1.cxx:130
TH1.cxx:131
TH1.cxx:132
TH1.cxx:133
TH1.cxx:134
TH1.cxx:135
TH1.cxx:136
TH1.cxx:137
TH1.cxx:138
TH1.cxx:139
TH1.cxx:140
TH1.cxx:141
TH1.cxx:142
TH1.cxx:143
TH1.cxx:144
TH1.cxx:145
TH1.cxx:146
TH1.cxx:147
TH1.cxx:148
TH1.cxx:149
TH1.cxx:150
TH1.cxx:151
TH1.cxx:152
TH1.cxx:153
TH1.cxx:154
TH1.cxx:155
TH1.cxx:156
TH1.cxx:157
TH1.cxx:158
TH1.cxx:159
TH1.cxx:160
TH1.cxx:161
TH1.cxx:162
TH1.cxx:163
TH1.cxx:164
TH1.cxx:165
TH1.cxx:166
TH1.cxx:167
TH1.cxx:168
TH1.cxx:169
TH1.cxx:170
TH1.cxx:171
TH1.cxx:172
TH1.cxx:173
TH1.cxx:174
TH1.cxx:175
TH1.cxx:176
TH1.cxx:177
TH1.cxx:178
TH1.cxx:179
TH1.cxx:180
TH1.cxx:181
TH1.cxx:182
TH1.cxx:183
TH1.cxx:184
TH1.cxx:185
TH1.cxx:186
TH1.cxx:187
TH1.cxx:188
TH1.cxx:189
TH1.cxx:190
TH1.cxx:191
TH1.cxx:192
TH1.cxx:193
TH1.cxx:194
TH1.cxx:195
TH1.cxx:196
TH1.cxx:197
TH1.cxx:198
TH1.cxx:199
TH1.cxx:200
TH1.cxx:201
TH1.cxx:202
TH1.cxx:203
TH1.cxx:204
TH1.cxx:205
TH1.cxx:206
TH1.cxx:207
TH1.cxx:208
TH1.cxx:209
TH1.cxx:210
TH1.cxx:211
TH1.cxx:212
TH1.cxx:213
TH1.cxx:214
TH1.cxx:215
TH1.cxx:216
TH1.cxx:217
TH1.cxx:218
TH1.cxx:219
TH1.cxx:220
TH1.cxx:221
TH1.cxx:222
TH1.cxx:223
TH1.cxx:224
TH1.cxx:225
TH1.cxx:226
TH1.cxx:227
TH1.cxx:228
TH1.cxx:229
TH1.cxx:230
TH1.cxx:231
TH1.cxx:232
TH1.cxx:233
TH1.cxx:234
TH1.cxx:235
TH1.cxx:236
TH1.cxx:237
TH1.cxx:238
TH1.cxx:239
TH1.cxx:240
TH1.cxx:241
TH1.cxx:242
TH1.cxx:243
TH1.cxx:244
TH1.cxx:245
TH1.cxx:246
TH1.cxx:247
TH1.cxx:248
TH1.cxx:249
TH1.cxx:250
TH1.cxx:251
TH1.cxx:252
TH1.cxx:253
TH1.cxx:254
TH1.cxx:255
TH1.cxx:256
TH1.cxx:257
TH1.cxx:258
TH1.cxx:259
TH1.cxx:260
TH1.cxx:261
TH1.cxx:262
TH1.cxx:263
TH1.cxx:264
TH1.cxx:265
TH1.cxx:266
TH1.cxx:267
TH1.cxx:268
TH1.cxx:269
TH1.cxx:270
TH1.cxx:271
TH1.cxx:272
TH1.cxx:273
TH1.cxx:274
TH1.cxx:275
TH1.cxx:276
TH1.cxx:277
TH1.cxx:278
TH1.cxx:279
TH1.cxx:280
TH1.cxx:281
TH1.cxx:282
TH1.cxx:283
TH1.cxx:284
TH1.cxx:285
TH1.cxx:286
TH1.cxx:287
TH1.cxx:288
TH1.cxx:289
TH1.cxx:290
TH1.cxx:291
TH1.cxx:292
TH1.cxx:293
TH1.cxx:294
TH1.cxx:295
TH1.cxx:296
TH1.cxx:297
TH1.cxx:298
TH1.cxx:299
TH1.cxx:300
TH1.cxx:301
TH1.cxx:302
TH1.cxx:303
TH1.cxx:304
TH1.cxx:305
TH1.cxx:306
TH1.cxx:307
TH1.cxx:308
TH1.cxx:309
TH1.cxx:310
TH1.cxx:311
TH1.cxx:312
TH1.cxx:313
TH1.cxx:314
TH1.cxx:315
TH1.cxx:316
TH1.cxx:317
TH1.cxx:318
TH1.cxx:319
TH1.cxx:320
TH1.cxx:321
TH1.cxx:322
TH1.cxx:323
TH1.cxx:324
TH1.cxx:325
TH1.cxx:326
TH1.cxx:327
TH1.cxx:328
TH1.cxx:329
TH1.cxx:330
TH1.cxx:331
TH1.cxx:332
TH1.cxx:333
TH1.cxx:334
TH1.cxx:335
TH1.cxx:336
TH1.cxx:337
TH1.cxx:338
TH1.cxx:339
TH1.cxx:340
TH1.cxx:341
TH1.cxx:342
TH1.cxx:343
TH1.cxx:344
TH1.cxx:345
TH1.cxx:346
TH1.cxx:347
TH1.cxx:348
TH1.cxx:349
TH1.cxx:350
TH1.cxx:351
TH1.cxx:352
TH1.cxx:353
TH1.cxx:354
TH1.cxx:355
TH1.cxx:356
TH1.cxx:357
TH1.cxx:358
TH1.cxx:359
TH1.cxx:360
TH1.cxx:361
TH1.cxx:362
TH1.cxx:363
TH1.cxx:364
TH1.cxx:365
TH1.cxx:366
TH1.cxx:367
TH1.cxx:368
TH1.cxx:369
TH1.cxx:370
TH1.cxx:371
TH1.cxx:372
TH1.cxx:373
TH1.cxx:374
TH1.cxx:375
TH1.cxx:376
TH1.cxx:377
TH1.cxx:378
TH1.cxx:379
TH1.cxx:380
TH1.cxx:381
TH1.cxx:382
TH1.cxx:383
TH1.cxx:384
TH1.cxx:385
TH1.cxx:386
TH1.cxx:387
TH1.cxx:388
TH1.cxx:389
TH1.cxx:390
TH1.cxx:391
TH1.cxx:392
TH1.cxx:393
TH1.cxx:394
TH1.cxx:395
TH1.cxx:396
TH1.cxx:397
TH1.cxx:398
TH1.cxx:399
TH1.cxx:400
TH1.cxx:401
TH1.cxx:402
TH1.cxx:403
TH1.cxx:404
TH1.cxx:405
TH1.cxx:406
TH1.cxx:407
TH1.cxx:408
TH1.cxx:409
TH1.cxx:410
TH1.cxx:411
TH1.cxx:412
TH1.cxx:413
TH1.cxx:414
TH1.cxx:415
TH1.cxx:416
TH1.cxx:417
TH1.cxx:418
TH1.cxx:419
TH1.cxx:420
TH1.cxx:421
TH1.cxx:422
TH1.cxx:423
TH1.cxx:424
TH1.cxx:425
TH1.cxx:426
TH1.cxx:427
TH1.cxx:428
TH1.cxx:429
TH1.cxx:430
TH1.cxx:431
TH1.cxx:432
TH1.cxx:433
TH1.cxx:434
TH1.cxx:435
TH1.cxx:436
TH1.cxx:437
TH1.cxx:438
TH1.cxx:439
TH1.cxx:440
TH1.cxx:441
TH1.cxx:442
TH1.cxx:443
TH1.cxx:444
TH1.cxx:445
TH1.cxx:446
TH1.cxx:447
TH1.cxx:448
TH1.cxx:449
TH1.cxx:450
TH1.cxx:451
TH1.cxx:452
TH1.cxx:453
TH1.cxx:454
TH1.cxx:455
TH1.cxx:456
TH1.cxx:457
TH1.cxx:458
TH1.cxx:459
TH1.cxx:460
TH1.cxx:461
TH1.cxx:462
TH1.cxx:463
TH1.cxx:464
TH1.cxx:465
TH1.cxx:466
TH1.cxx:467
TH1.cxx:468
TH1.cxx:469
TH1.cxx:470
TH1.cxx:471
TH1.cxx:472
TH1.cxx:473
TH1.cxx:474
TH1.cxx:475
TH1.cxx:476
TH1.cxx:477
TH1.cxx:478
TH1.cxx:479
TH1.cxx:480
TH1.cxx:481
TH1.cxx:482
TH1.cxx:483
TH1.cxx:484
TH1.cxx:485
TH1.cxx:486
TH1.cxx:487
TH1.cxx:488
TH1.cxx:489
TH1.cxx:490
TH1.cxx:491
TH1.cxx:492
TH1.cxx:493
TH1.cxx:494
TH1.cxx:495
TH1.cxx:496
TH1.cxx:497
TH1.cxx:498
TH1.cxx:499
TH1.cxx:500
TH1.cxx:501
TH1.cxx:502
TH1.cxx:503
TH1.cxx:504
TH1.cxx:505
TH1.cxx:506
TH1.cxx:507
TH1.cxx:508
TH1.cxx:509
TH1.cxx:510
TH1.cxx:511
TH1.cxx:512
TH1.cxx:513
TH1.cxx:514
TH1.cxx:515
TH1.cxx:516
TH1.cxx:517
TH1.cxx:518
TH1.cxx:519
TH1.cxx:520
TH1.cxx:521
TH1.cxx:522
TH1.cxx:523
TH1.cxx:524
TH1.cxx:525
TH1.cxx:526
TH1.cxx:527
TH1.cxx:528
TH1.cxx:529
TH1.cxx:530
TH1.cxx:531
TH1.cxx:532
TH1.cxx:533
TH1.cxx:534
TH1.cxx:535
TH1.cxx:536
TH1.cxx:537
TH1.cxx:538
TH1.cxx:539
TH1.cxx:540
TH1.cxx:541
TH1.cxx:542
TH1.cxx:543
TH1.cxx:544
TH1.cxx:545
TH1.cxx:546
TH1.cxx:547
TH1.cxx:548
TH1.cxx:549
TH1.cxx:550
TH1.cxx:551
TH1.cxx:552
TH1.cxx:553
TH1.cxx:554
TH1.cxx:555
TH1.cxx:556
TH1.cxx:557
TH1.cxx:558
TH1.cxx:559
TH1.cxx:560
TH1.cxx:561
TH1.cxx:562
TH1.cxx:563
TH1.cxx:564
TH1.cxx:565
TH1.cxx:566
TH1.cxx:567
TH1.cxx:568
TH1.cxx:569
TH1.cxx:570
TH1.cxx:571
TH1.cxx:572
TH1.cxx:573
TH1.cxx:574
TH1.cxx:575
TH1.cxx:576
TH1.cxx:577
TH1.cxx:578
TH1.cxx:579
TH1.cxx:580
TH1.cxx:581
TH1.cxx:582
TH1.cxx:583
TH1.cxx:584
TH1.cxx:585
TH1.cxx:586
TH1.cxx:587
TH1.cxx:588
TH1.cxx:589
TH1.cxx:590
TH1.cxx:591
TH1.cxx:592
TH1.cxx:593
TH1.cxx:594
TH1.cxx:595
TH1.cxx:596
TH1.cxx:597
TH1.cxx:598
TH1.cxx:599
TH1.cxx:600
TH1.cxx:601
TH1.cxx:602
TH1.cxx:603
TH1.cxx:604
TH1.cxx:605
TH1.cxx:606
TH1.cxx:607
TH1.cxx:608
TH1.cxx:609
TH1.cxx:610
TH1.cxx:611
TH1.cxx:612
TH1.cxx:613
TH1.cxx:614
TH1.cxx:615
TH1.cxx:616
TH1.cxx:617
TH1.cxx:618
TH1.cxx:619
TH1.cxx:620
TH1.cxx:621
TH1.cxx:622
TH1.cxx:623
TH1.cxx:624
TH1.cxx:625
TH1.cxx:626
TH1.cxx:627
TH1.cxx:628
TH1.cxx:629
TH1.cxx:630
TH1.cxx:631
TH1.cxx:632
TH1.cxx:633
TH1.cxx:634
TH1.cxx:635
TH1.cxx:636
TH1.cxx:637
TH1.cxx:638
TH1.cxx:639
TH1.cxx:640
TH1.cxx:641
TH1.cxx:642
TH1.cxx:643
TH1.cxx:644
TH1.cxx:645
TH1.cxx:646
TH1.cxx:647
TH1.cxx:648
TH1.cxx:649
TH1.cxx:650
TH1.cxx:651
TH1.cxx:652
TH1.cxx:653
TH1.cxx:654
TH1.cxx:655
TH1.cxx:656
TH1.cxx:657
TH1.cxx:658
TH1.cxx:659
TH1.cxx:660
TH1.cxx:661
TH1.cxx:662
TH1.cxx:663
TH1.cxx:664
TH1.cxx:665
TH1.cxx:666
TH1.cxx:667
TH1.cxx:668
TH1.cxx:669
TH1.cxx:670
TH1.cxx:671
TH1.cxx:672
TH1.cxx:673
TH1.cxx:674
TH1.cxx:675
TH1.cxx:676
TH1.cxx:677
TH1.cxx:678
TH1.cxx:679
TH1.cxx:680
TH1.cxx:681
TH1.cxx:682
TH1.cxx:683
TH1.cxx:684
TH1.cxx:685
TH1.cxx:686
TH1.cxx:687
TH1.cxx:688
TH1.cxx:689
TH1.cxx:690
TH1.cxx:691
TH1.cxx:692
TH1.cxx:693
TH1.cxx:694
TH1.cxx:695
TH1.cxx:696
TH1.cxx:697
TH1.cxx:698
TH1.cxx:699
TH1.cxx:700
TH1.cxx:701
TH1.cxx:702
TH1.cxx:703
TH1.cxx:704
TH1.cxx:705
TH1.cxx:706
TH1.cxx:707
TH1.cxx:708
TH1.cxx:709
TH1.cxx:710
TH1.cxx:711
TH1.cxx:712
TH1.cxx:713
TH1.cxx:714
TH1.cxx:715
TH1.cxx:716
TH1.cxx:717
TH1.cxx:718
TH1.cxx:719
TH1.cxx:720
TH1.cxx:721
TH1.cxx:722
TH1.cxx:723
TH1.cxx:724
TH1.cxx:725
TH1.cxx:726
TH1.cxx:727
TH1.cxx:728
TH1.cxx:729
TH1.cxx:730
TH1.cxx:731
TH1.cxx:732
TH1.cxx:733
TH1.cxx:734
TH1.cxx:735
TH1.cxx:736
TH1.cxx:737
TH1.cxx:738
TH1.cxx:739
TH1.cxx:740
TH1.cxx:741
TH1.cxx:742
TH1.cxx:743
TH1.cxx:744
TH1.cxx:745
TH1.cxx:746
TH1.cxx:747
TH1.cxx:748
TH1.cxx:749
TH1.cxx:750
TH1.cxx:751
TH1.cxx:752
TH1.cxx:753
TH1.cxx:754
TH1.cxx:755
TH1.cxx:756
TH1.cxx:757
TH1.cxx:758
TH1.cxx:759
TH1.cxx:760
TH1.cxx:761
TH1.cxx:762
TH1.cxx:763
TH1.cxx:764
TH1.cxx:765
TH1.cxx:766
TH1.cxx:767
TH1.cxx:768
TH1.cxx:769
TH1.cxx:770
TH1.cxx:771
TH1.cxx:772
TH1.cxx:773
TH1.cxx:774
TH1.cxx:775
TH1.cxx:776
TH1.cxx:777
TH1.cxx:778
TH1.cxx:779
TH1.cxx:780
TH1.cxx:781
TH1.cxx:782
TH1.cxx:783
TH1.cxx:784
TH1.cxx:785
TH1.cxx:786
TH1.cxx:787
TH1.cxx:788
TH1.cxx:789
TH1.cxx:790
TH1.cxx:791
TH1.cxx:792
TH1.cxx:793
TH1.cxx:794
TH1.cxx:795
TH1.cxx:796
TH1.cxx:797
TH1.cxx:798
TH1.cxx:799
TH1.cxx:800
TH1.cxx:801
TH1.cxx:802
TH1.cxx:803
TH1.cxx:804
TH1.cxx:805
TH1.cxx:806
TH1.cxx:807
TH1.cxx:808
TH1.cxx:809
TH1.cxx:810
TH1.cxx:811
TH1.cxx:812
TH1.cxx:813
TH1.cxx:814
TH1.cxx:815
TH1.cxx:816
TH1.cxx:817
TH1.cxx:818
TH1.cxx:819
TH1.cxx:820
TH1.cxx:821
TH1.cxx:822
TH1.cxx:823
TH1.cxx:824
TH1.cxx:825
TH1.cxx:826
TH1.cxx:827
TH1.cxx:828
TH1.cxx:829
TH1.cxx:830
TH1.cxx:831
TH1.cxx:832
TH1.cxx:833
TH1.cxx:834
TH1.cxx:835
TH1.cxx:836
TH1.cxx:837
TH1.cxx:838
TH1.cxx:839
TH1.cxx:840
TH1.cxx:841
TH1.cxx:842
TH1.cxx:843
TH1.cxx:844
TH1.cxx:845
TH1.cxx:846
TH1.cxx:847
TH1.cxx:848
TH1.cxx:849
TH1.cxx:850
TH1.cxx:851
TH1.cxx:852
TH1.cxx:853
TH1.cxx:854
TH1.cxx:855
TH1.cxx:856
TH1.cxx:857
TH1.cxx:858
TH1.cxx:859
TH1.cxx:860
TH1.cxx:861
TH1.cxx:862
TH1.cxx:863
TH1.cxx:864
TH1.cxx:865
TH1.cxx:866
TH1.cxx:867
TH1.cxx:868
TH1.cxx:869
TH1.cxx:870
TH1.cxx:871
TH1.cxx:872
TH1.cxx:873
TH1.cxx:874
TH1.cxx:875
TH1.cxx:876
TH1.cxx:877
TH1.cxx:878
TH1.cxx:879
TH1.cxx:880
TH1.cxx:881
TH1.cxx:882
TH1.cxx:883
TH1.cxx:884
TH1.cxx:885
TH1.cxx:886
TH1.cxx:887
TH1.cxx:888
TH1.cxx:889
TH1.cxx:890
TH1.cxx:891
TH1.cxx:892
TH1.cxx:893
TH1.cxx:894
TH1.cxx:895
TH1.cxx:896
TH1.cxx:897
TH1.cxx:898
TH1.cxx:899
TH1.cxx:900
TH1.cxx:901
TH1.cxx:902
TH1.cxx:903
TH1.cxx:904
TH1.cxx:905
TH1.cxx:906
TH1.cxx:907
TH1.cxx:908
TH1.cxx:909
TH1.cxx:910
TH1.cxx:911
TH1.cxx:912
TH1.cxx:913
TH1.cxx:914
TH1.cxx:915
TH1.cxx:916
TH1.cxx:917
TH1.cxx:918
TH1.cxx:919
TH1.cxx:920
TH1.cxx:921
TH1.cxx:922
TH1.cxx:923
TH1.cxx:924
TH1.cxx:925
TH1.cxx:926
TH1.cxx:927
TH1.cxx:928
TH1.cxx:929
TH1.cxx:930
TH1.cxx:931
TH1.cxx:932
TH1.cxx:933
TH1.cxx:934
TH1.cxx:935
TH1.cxx:936
TH1.cxx:937
TH1.cxx:938
TH1.cxx:939
TH1.cxx:940
TH1.cxx:941
TH1.cxx:942
TH1.cxx:943
TH1.cxx:944
TH1.cxx:945
TH1.cxx:946
TH1.cxx:947
TH1.cxx:948
TH1.cxx:949
TH1.cxx:950
TH1.cxx:951
TH1.cxx:952
TH1.cxx:953
TH1.cxx:954
TH1.cxx:955
TH1.cxx:956
TH1.cxx:957
TH1.cxx:958
TH1.cxx:959
TH1.cxx:960
TH1.cxx:961
TH1.cxx:962
TH1.cxx:963
TH1.cxx:964
TH1.cxx:965
TH1.cxx:966
TH1.cxx:967
TH1.cxx:968
TH1.cxx:969
TH1.cxx:970
TH1.cxx:971
TH1.cxx:972
TH1.cxx:973
TH1.cxx:974
TH1.cxx:975
TH1.cxx:976
TH1.cxx:977
TH1.cxx:978
TH1.cxx:979
TH1.cxx:980
TH1.cxx:981
TH1.cxx:982
TH1.cxx:983
TH1.cxx:984
TH1.cxx:985
TH1.cxx:986
TH1.cxx:987
TH1.cxx:988
TH1.cxx:989
TH1.cxx:990
TH1.cxx:991
TH1.cxx:992
TH1.cxx:993
TH1.cxx:994
TH1.cxx:995
TH1.cxx:996
TH1.cxx:997
TH1.cxx:998
TH1.cxx:999
TH1.cxx:1000
TH1.cxx:1001
TH1.cxx:1002
TH1.cxx:1003
TH1.cxx:1004
TH1.cxx:1005
TH1.cxx:1006
TH1.cxx:1007
TH1.cxx:1008
TH1.cxx:1009
TH1.cxx:1010
TH1.cxx:1011
TH1.cxx:1012
TH1.cxx:1013
TH1.cxx:1014
TH1.cxx:1015
TH1.cxx:1016
TH1.cxx:1017
TH1.cxx:1018
TH1.cxx:1019
TH1.cxx:1020
TH1.cxx:1021
TH1.cxx:1022
TH1.cxx:1023
TH1.cxx:1024
TH1.cxx:1025
TH1.cxx:1026
TH1.cxx:1027
TH1.cxx:1028
TH1.cxx:1029
TH1.cxx:1030
TH1.cxx:1031
TH1.cxx:1032
TH1.cxx:1033
TH1.cxx:1034
TH1.cxx:1035
TH1.cxx:1036
TH1.cxx:1037
TH1.cxx:1038
TH1.cxx:1039
TH1.cxx:1040
TH1.cxx:1041
TH1.cxx:1042
TH1.cxx:1043
TH1.cxx:1044
TH1.cxx:1045
TH1.cxx:1046
TH1.cxx:1047
TH1.cxx:1048
TH1.cxx:1049
TH1.cxx:1050
TH1.cxx:1051
TH1.cxx:1052
TH1.cxx:1053
TH1.cxx:1054
TH1.cxx:1055
TH1.cxx:1056
TH1.cxx:1057
TH1.cxx:1058
TH1.cxx:1059
TH1.cxx:1060
TH1.cxx:1061
TH1.cxx:1062
TH1.cxx:1063
TH1.cxx:1064
TH1.cxx:1065
TH1.cxx:1066
TH1.cxx:1067
TH1.cxx:1068
TH1.cxx:1069
TH1.cxx:1070
TH1.cxx:1071
TH1.cxx:1072
TH1.cxx:1073
TH1.cxx:1074
TH1.cxx:1075
TH1.cxx:1076
TH1.cxx:1077
TH1.cxx:1078
TH1.cxx:1079
TH1.cxx:1080
TH1.cxx:1081
TH1.cxx:1082
TH1.cxx:1083
TH1.cxx:1084
TH1.cxx:1085
TH1.cxx:1086
TH1.cxx:1087
TH1.cxx:1088
TH1.cxx:1089
TH1.cxx:1090
TH1.cxx:1091
TH1.cxx:1092
TH1.cxx:1093
TH1.cxx:1094
TH1.cxx:1095
TH1.cxx:1096
TH1.cxx:1097
TH1.cxx:1098
TH1.cxx:1099
TH1.cxx:1100
TH1.cxx:1101
TH1.cxx:1102
TH1.cxx:1103
TH1.cxx:1104
TH1.cxx:1105
TH1.cxx:1106
TH1.cxx:1107
TH1.cxx:1108
TH1.cxx:1109
TH1.cxx:1110
TH1.cxx:1111
TH1.cxx:1112
TH1.cxx:1113
TH1.cxx:1114
TH1.cxx:1115
TH1.cxx:1116
TH1.cxx:1117
TH1.cxx:1118
TH1.cxx:1119
TH1.cxx:1120
TH1.cxx:1121
TH1.cxx:1122
TH1.cxx:1123
TH1.cxx:1124
TH1.cxx:1125
TH1.cxx:1126
TH1.cxx:1127
TH1.cxx:1128
TH1.cxx:1129
TH1.cxx:1130
TH1.cxx:1131
TH1.cxx:1132
TH1.cxx:1133
TH1.cxx:1134
TH1.cxx:1135
TH1.cxx:1136
TH1.cxx:1137
TH1.cxx:1138
TH1.cxx:1139
TH1.cxx:1140
TH1.cxx:1141
TH1.cxx:1142
TH1.cxx:1143
TH1.cxx:1144
TH1.cxx:1145
TH1.cxx:1146
TH1.cxx:1147
TH1.cxx:1148
TH1.cxx:1149
TH1.cxx:1150
TH1.cxx:1151
TH1.cxx:1152
TH1.cxx:1153
TH1.cxx:1154
TH1.cxx:1155
TH1.cxx:1156
TH1.cxx:1157
TH1.cxx:1158
TH1.cxx:1159
TH1.cxx:1160
TH1.cxx:1161
TH1.cxx:1162
TH1.cxx:1163
TH1.cxx:1164
TH1.cxx:1165
TH1.cxx:1166
TH1.cxx:1167
TH1.cxx:1168
TH1.cxx:1169
TH1.cxx:1170
TH1.cxx:1171
TH1.cxx:1172
TH1.cxx:1173
TH1.cxx:1174
TH1.cxx:1175
TH1.cxx:1176
TH1.cxx:1177
TH1.cxx:1178
TH1.cxx:1179
TH1.cxx:1180
TH1.cxx:1181
TH1.cxx:1182
TH1.cxx:1183
TH1.cxx:1184
TH1.cxx:1185
TH1.cxx:1186
TH1.cxx:1187
TH1.cxx:1188
TH1.cxx:1189
TH1.cxx:1190
TH1.cxx:1191
TH1.cxx:1192
TH1.cxx:1193
TH1.cxx:1194
TH1.cxx:1195
TH1.cxx:1196
TH1.cxx:1197
TH1.cxx:1198
TH1.cxx:1199
TH1.cxx:1200
TH1.cxx:1201
TH1.cxx:1202
TH1.cxx:1203
TH1.cxx:1204
TH1.cxx:1205
TH1.cxx:1206
TH1.cxx:1207
TH1.cxx:1208
TH1.cxx:1209
TH1.cxx:1210
TH1.cxx:1211
TH1.cxx:1212
TH1.cxx:1213
TH1.cxx:1214
TH1.cxx:1215
TH1.cxx:1216
TH1.cxx:1217
TH1.cxx:1218
TH1.cxx:1219
TH1.cxx:1220
TH1.cxx:1221
TH1.cxx:1222
TH1.cxx:1223
TH1.cxx:1224
TH1.cxx:1225
TH1.cxx:1226
TH1.cxx:1227
TH1.cxx:1228
TH1.cxx:1229
TH1.cxx:1230
TH1.cxx:1231
TH1.cxx:1232
TH1.cxx:1233
TH1.cxx:1234
TH1.cxx:1235
TH1.cxx:1236
TH1.cxx:1237
TH1.cxx:1238
TH1.cxx:1239
TH1.cxx:1240
TH1.cxx:1241
TH1.cxx:1242
TH1.cxx:1243
TH1.cxx:1244
TH1.cxx:1245
TH1.cxx:1246
TH1.cxx:1247
TH1.cxx:1248
TH1.cxx:1249
TH1.cxx:1250
TH1.cxx:1251
TH1.cxx:1252
TH1.cxx:1253
TH1.cxx:1254
TH1.cxx:1255
TH1.cxx:1256
TH1.cxx:1257
TH1.cxx:1258
TH1.cxx:1259
TH1.cxx:1260
TH1.cxx:1261
TH1.cxx:1262
TH1.cxx:1263
TH1.cxx:1264
TH1.cxx:1265
TH1.cxx:1266
TH1.cxx:1267
TH1.cxx:1268
TH1.cxx:1269
TH1.cxx:1270
TH1.cxx:1271
TH1.cxx:1272
TH1.cxx:1273
TH1.cxx:1274
TH1.cxx:1275
TH1.cxx:1276
TH1.cxx:1277
TH1.cxx:1278
TH1.cxx:1279
TH1.cxx:1280
TH1.cxx:1281
TH1.cxx:1282
TH1.cxx:1283
TH1.cxx:1284
TH1.cxx:1285
TH1.cxx:1286
TH1.cxx:1287
TH1.cxx:1288
TH1.cxx:1289
TH1.cxx:1290
TH1.cxx:1291
TH1.cxx:1292
TH1.cxx:1293
TH1.cxx:1294
TH1.cxx:1295
TH1.cxx:1296
TH1.cxx:1297
TH1.cxx:1298
TH1.cxx:1299
TH1.cxx:1300
TH1.cxx:1301
TH1.cxx:1302
TH1.cxx:1303
TH1.cxx:1304
TH1.cxx:1305
TH1.cxx:1306
TH1.cxx:1307
TH1.cxx:1308
TH1.cxx:1309
TH1.cxx:1310
TH1.cxx:1311
TH1.cxx:1312
TH1.cxx:1313
TH1.cxx:1314
TH1.cxx:1315
TH1.cxx:1316
TH1.cxx:1317
TH1.cxx:1318
TH1.cxx:1319
TH1.cxx:1320
TH1.cxx:1321
TH1.cxx:1322
TH1.cxx:1323
TH1.cxx:1324
TH1.cxx:1325
TH1.cxx:1326
TH1.cxx:1327
TH1.cxx:1328
TH1.cxx:1329
TH1.cxx:1330
TH1.cxx:1331
TH1.cxx:1332
TH1.cxx:1333
TH1.cxx:1334
TH1.cxx:1335
TH1.cxx:1336
TH1.cxx:1337
TH1.cxx:1338
TH1.cxx:1339
TH1.cxx:1340
TH1.cxx:1341
TH1.cxx:1342
TH1.cxx:1343
TH1.cxx:1344
TH1.cxx:1345
TH1.cxx:1346
TH1.cxx:1347
TH1.cxx:1348
TH1.cxx:1349
TH1.cxx:1350
TH1.cxx:1351
TH1.cxx:1352
TH1.cxx:1353
TH1.cxx:1354
TH1.cxx:1355
TH1.cxx:1356
TH1.cxx:1357
TH1.cxx:1358
TH1.cxx:1359
TH1.cxx:1360
TH1.cxx:1361
TH1.cxx:1362
TH1.cxx:1363
TH1.cxx:1364
TH1.cxx:1365
TH1.cxx:1366
TH1.cxx:1367
TH1.cxx:1368
TH1.cxx:1369
TH1.cxx:1370
TH1.cxx:1371
TH1.cxx:1372
TH1.cxx:1373
TH1.cxx:1374
TH1.cxx:1375
TH1.cxx:1376
TH1.cxx:1377
TH1.cxx:1378
TH1.cxx:1379
TH1.cxx:1380
TH1.cxx:1381
TH1.cxx:1382
TH1.cxx:1383
TH1.cxx:1384
TH1.cxx:1385
TH1.cxx:1386
TH1.cxx:1387
TH1.cxx:1388
TH1.cxx:1389
TH1.cxx:1390
TH1.cxx:1391
TH1.cxx:1392
TH1.cxx:1393
TH1.cxx:1394
TH1.cxx:1395
TH1.cxx:1396
TH1.cxx:1397
TH1.cxx:1398
TH1.cxx:1399
TH1.cxx:1400
TH1.cxx:1401
TH1.cxx:1402
TH1.cxx:1403
TH1.cxx:1404
TH1.cxx:1405
TH1.cxx:1406
TH1.cxx:1407
TH1.cxx:1408
TH1.cxx:1409
TH1.cxx:1410
TH1.cxx:1411
TH1.cxx:1412
TH1.cxx:1413
TH1.cxx:1414
TH1.cxx:1415
TH1.cxx:1416
TH1.cxx:1417
TH1.cxx:1418
TH1.cxx:1419
TH1.cxx:1420
TH1.cxx:1421
TH1.cxx:1422
TH1.cxx:1423
TH1.cxx:1424
TH1.cxx:1425
TH1.cxx:1426
TH1.cxx:1427
TH1.cxx:1428
TH1.cxx:1429
TH1.cxx:1430
TH1.cxx:1431
TH1.cxx:1432
TH1.cxx:1433
TH1.cxx:1434
TH1.cxx:1435
TH1.cxx:1436
TH1.cxx:1437
TH1.cxx:1438
TH1.cxx:1439
TH1.cxx:1440
TH1.cxx:1441
TH1.cxx:1442
TH1.cxx:1443
TH1.cxx:1444
TH1.cxx:1445
TH1.cxx:1446
TH1.cxx:1447
TH1.cxx:1448
TH1.cxx:1449
TH1.cxx:1450
TH1.cxx:1451
TH1.cxx:1452
TH1.cxx:1453
TH1.cxx:1454
TH1.cxx:1455
TH1.cxx:1456
TH1.cxx:1457
TH1.cxx:1458
TH1.cxx:1459
TH1.cxx:1460
TH1.cxx:1461
TH1.cxx:1462
TH1.cxx:1463
TH1.cxx:1464
TH1.cxx:1465
TH1.cxx:1466
TH1.cxx:1467
TH1.cxx:1468
TH1.cxx:1469
TH1.cxx:1470
TH1.cxx:1471
TH1.cxx:1472
TH1.cxx:1473
TH1.cxx:1474
TH1.cxx:1475
TH1.cxx:1476
TH1.cxx:1477
TH1.cxx:1478
TH1.cxx:1479
TH1.cxx:1480
TH1.cxx:1481
TH1.cxx:1482
TH1.cxx:1483
TH1.cxx:1484
TH1.cxx:1485
TH1.cxx:1486
TH1.cxx:1487
TH1.cxx:1488
TH1.cxx:1489
TH1.cxx:1490
TH1.cxx:1491
TH1.cxx:1492
TH1.cxx:1493
TH1.cxx:1494
TH1.cxx:1495
TH1.cxx:1496
TH1.cxx:1497
TH1.cxx:1498
TH1.cxx:1499
TH1.cxx:1500
TH1.cxx:1501
TH1.cxx:1502
TH1.cxx:1503
TH1.cxx:1504
TH1.cxx:1505
TH1.cxx:1506
TH1.cxx:1507
TH1.cxx:1508
TH1.cxx:1509
TH1.cxx:1510
TH1.cxx:1511
TH1.cxx:1512
TH1.cxx:1513
TH1.cxx:1514
TH1.cxx:1515
TH1.cxx:1516
TH1.cxx:1517
TH1.cxx:1518
TH1.cxx:1519
TH1.cxx:1520
TH1.cxx:1521
TH1.cxx:1522
TH1.cxx:1523
TH1.cxx:1524
TH1.cxx:1525
TH1.cxx:1526
TH1.cxx:1527
TH1.cxx:1528
TH1.cxx:1529
TH1.cxx:1530
TH1.cxx:1531
TH1.cxx:1532
TH1.cxx:1533
TH1.cxx:1534
TH1.cxx:1535
TH1.cxx:1536
TH1.cxx:1537
TH1.cxx:1538
TH1.cxx:1539
TH1.cxx:1540
TH1.cxx:1541
TH1.cxx:1542
TH1.cxx:1543
TH1.cxx:1544
TH1.cxx:1545
TH1.cxx:1546
TH1.cxx:1547
TH1.cxx:1548
TH1.cxx:1549
TH1.cxx:1550
TH1.cxx:1551
TH1.cxx:1552
TH1.cxx:1553
TH1.cxx:1554
TH1.cxx:1555
TH1.cxx:1556
TH1.cxx:1557
TH1.cxx:1558
TH1.cxx:1559
TH1.cxx:1560
TH1.cxx:1561
TH1.cxx:1562
TH1.cxx:1563
TH1.cxx:1564
TH1.cxx:1565
TH1.cxx:1566
TH1.cxx:1567
TH1.cxx:1568
TH1.cxx:1569
TH1.cxx:1570
TH1.cxx:1571
TH1.cxx:1572
TH1.cxx:1573
TH1.cxx:1574
TH1.cxx:1575
TH1.cxx:1576
TH1.cxx:1577
TH1.cxx:1578
TH1.cxx:1579
TH1.cxx:1580
TH1.cxx:1581
TH1.cxx:1582
TH1.cxx:1583
TH1.cxx:1584
TH1.cxx:1585
TH1.cxx:1586
TH1.cxx:1587
TH1.cxx:1588
TH1.cxx:1589
TH1.cxx:1590
TH1.cxx:1591
TH1.cxx:1592
TH1.cxx:1593
TH1.cxx:1594
TH1.cxx:1595
TH1.cxx:1596
TH1.cxx:1597
TH1.cxx:1598
TH1.cxx:1599
TH1.cxx:1600
TH1.cxx:1601
TH1.cxx:1602
TH1.cxx:1603
TH1.cxx:1604
TH1.cxx:1605
TH1.cxx:1606
TH1.cxx:1607
TH1.cxx:1608
TH1.cxx:1609
TH1.cxx:1610
TH1.cxx:1611
TH1.cxx:1612
TH1.cxx:1613
TH1.cxx:1614
TH1.cxx:1615
TH1.cxx:1616
TH1.cxx:1617
TH1.cxx:1618
TH1.cxx:1619
TH1.cxx:1620
TH1.cxx:1621
TH1.cxx:1622
TH1.cxx:1623
TH1.cxx:1624
TH1.cxx:1625
TH1.cxx:1626
TH1.cxx:1627
TH1.cxx:1628
TH1.cxx:1629
TH1.cxx:1630
TH1.cxx:1631
TH1.cxx:1632
TH1.cxx:1633
TH1.cxx:1634
TH1.cxx:1635
TH1.cxx:1636
TH1.cxx:1637
TH1.cxx:1638
TH1.cxx:1639
TH1.cxx:1640
TH1.cxx:1641
TH1.cxx:1642
TH1.cxx:1643
TH1.cxx:1644
TH1.cxx:1645
TH1.cxx:1646
TH1.cxx:1647
TH1.cxx:1648
TH1.cxx:1649
TH1.cxx:1650
TH1.cxx:1651
TH1.cxx:1652
TH1.cxx:1653
TH1.cxx:1654
TH1.cxx:1655
TH1.cxx:1656
TH1.cxx:1657
TH1.cxx:1658
TH1.cxx:1659
TH1.cxx:1660
TH1.cxx:1661
TH1.cxx:1662
TH1.cxx:1663
TH1.cxx:1664
TH1.cxx:1665
TH1.cxx:1666
TH1.cxx:1667
TH1.cxx:1668
TH1.cxx:1669
TH1.cxx:1670
TH1.cxx:1671
TH1.cxx:1672
TH1.cxx:1673
TH1.cxx:1674
TH1.cxx:1675
TH1.cxx:1676
TH1.cxx:1677
TH1.cxx:1678
TH1.cxx:1679
TH1.cxx:1680
TH1.cxx:1681
TH1.cxx:1682
TH1.cxx:1683
TH1.cxx:1684
TH1.cxx:1685
TH1.cxx:1686
TH1.cxx:1687
TH1.cxx:1688
TH1.cxx:1689
TH1.cxx:1690
TH1.cxx:1691
TH1.cxx:1692
TH1.cxx:1693
TH1.cxx:1694
TH1.cxx:1695
TH1.cxx:1696
TH1.cxx:1697
TH1.cxx:1698
TH1.cxx:1699
TH1.cxx:1700
TH1.cxx:1701
TH1.cxx:1702
TH1.cxx:1703
TH1.cxx:1704
TH1.cxx:1705
TH1.cxx:1706
TH1.cxx:1707
TH1.cxx:1708
TH1.cxx:1709
TH1.cxx:1710
TH1.cxx:1711
TH1.cxx:1712
TH1.cxx:1713
TH1.cxx:1714
TH1.cxx:1715
TH1.cxx:1716
TH1.cxx:1717
TH1.cxx:1718
TH1.cxx:1719
TH1.cxx:1720
TH1.cxx:1721
TH1.cxx:1722
TH1.cxx:1723
TH1.cxx:1724
TH1.cxx:1725
TH1.cxx:1726
TH1.cxx:1727
TH1.cxx:1728
TH1.cxx:1729
TH1.cxx:1730
TH1.cxx:1731
TH1.cxx:1732
TH1.cxx:1733
TH1.cxx:1734
TH1.cxx:1735
TH1.cxx:1736
TH1.cxx:1737
TH1.cxx:1738
TH1.cxx:1739
TH1.cxx:1740
TH1.cxx:1741
TH1.cxx:1742
TH1.cxx:1743
TH1.cxx:1744
TH1.cxx:1745
TH1.cxx:1746
TH1.cxx:1747
TH1.cxx:1748
TH1.cxx:1749
TH1.cxx:1750
TH1.cxx:1751
TH1.cxx:1752
TH1.cxx:1753
TH1.cxx:1754
TH1.cxx:1755
TH1.cxx:1756
TH1.cxx:1757
TH1.cxx:1758
TH1.cxx:1759
TH1.cxx:1760
TH1.cxx:1761
TH1.cxx:1762
TH1.cxx:1763
TH1.cxx:1764
TH1.cxx:1765
TH1.cxx:1766
TH1.cxx:1767
TH1.cxx:1768
TH1.cxx:1769
TH1.cxx:1770
TH1.cxx:1771
TH1.cxx:1772
TH1.cxx:1773
TH1.cxx:1774
TH1.cxx:1775
TH1.cxx:1776
TH1.cxx:1777
TH1.cxx:1778
TH1.cxx:1779
TH1.cxx:1780
TH1.cxx:1781
TH1.cxx:1782
TH1.cxx:1783
TH1.cxx:1784
TH1.cxx:1785
TH1.cxx:1786
TH1.cxx:1787
TH1.cxx:1788
TH1.cxx:1789
TH1.cxx:1790
TH1.cxx:1791
TH1.cxx:1792
TH1.cxx:1793
TH1.cxx:1794
TH1.cxx:1795
TH1.cxx:1796
TH1.cxx:1797
TH1.cxx:1798
TH1.cxx:1799
TH1.cxx:1800
TH1.cxx:1801
TH1.cxx:1802
TH1.cxx:1803
TH1.cxx:1804
TH1.cxx:1805
TH1.cxx:1806
TH1.cxx:1807
TH1.cxx:1808
TH1.cxx:1809
TH1.cxx:1810
TH1.cxx:1811
TH1.cxx:1812
TH1.cxx:1813
TH1.cxx:1814
TH1.cxx:1815
TH1.cxx:1816
TH1.cxx:1817
TH1.cxx:1818
TH1.cxx:1819
TH1.cxx:1820
TH1.cxx:1821
TH1.cxx:1822
TH1.cxx:1823
TH1.cxx:1824
TH1.cxx:1825
TH1.cxx:1826
TH1.cxx:1827
TH1.cxx:1828
TH1.cxx:1829
TH1.cxx:1830
TH1.cxx:1831
TH1.cxx:1832
TH1.cxx:1833
TH1.cxx:1834
TH1.cxx:1835
TH1.cxx:1836
TH1.cxx:1837
TH1.cxx:1838
TH1.cxx:1839
TH1.cxx:1840
TH1.cxx:1841
TH1.cxx:1842
TH1.cxx:1843
TH1.cxx:1844
TH1.cxx:1845
TH1.cxx:1846
TH1.cxx:1847
TH1.cxx:1848
TH1.cxx:1849
TH1.cxx:1850
TH1.cxx:1851
TH1.cxx:1852
TH1.cxx:1853
TH1.cxx:1854
TH1.cxx:1855
TH1.cxx:1856
TH1.cxx:1857
TH1.cxx:1858
TH1.cxx:1859
TH1.cxx:1860
TH1.cxx:1861
TH1.cxx:1862
TH1.cxx:1863
TH1.cxx:1864
TH1.cxx:1865
TH1.cxx:1866
TH1.cxx:1867
TH1.cxx:1868
TH1.cxx:1869
TH1.cxx:1870
TH1.cxx:1871
TH1.cxx:1872
TH1.cxx:1873
TH1.cxx:1874
TH1.cxx:1875
TH1.cxx:1876
TH1.cxx:1877
TH1.cxx:1878
TH1.cxx:1879
TH1.cxx:1880
TH1.cxx:1881
TH1.cxx:1882
TH1.cxx:1883
TH1.cxx:1884
TH1.cxx:1885
TH1.cxx:1886
TH1.cxx:1887
TH1.cxx:1888
TH1.cxx:1889
TH1.cxx:1890
TH1.cxx:1891
TH1.cxx:1892
TH1.cxx:1893
TH1.cxx:1894
TH1.cxx:1895
TH1.cxx:1896
TH1.cxx:1897
TH1.cxx:1898
TH1.cxx:1899
TH1.cxx:1900
TH1.cxx:1901
TH1.cxx:1902
TH1.cxx:1903
TH1.cxx:1904
TH1.cxx:1905
TH1.cxx:1906
TH1.cxx:1907
TH1.cxx:1908
TH1.cxx:1909
TH1.cxx:1910
TH1.cxx:1911
TH1.cxx:1912
TH1.cxx:1913
TH1.cxx:1914
TH1.cxx:1915
TH1.cxx:1916
TH1.cxx:1917
TH1.cxx:1918
TH1.cxx:1919
TH1.cxx:1920
TH1.cxx:1921
TH1.cxx:1922
TH1.cxx:1923
TH1.cxx:1924
TH1.cxx:1925
TH1.cxx:1926
TH1.cxx:1927
TH1.cxx:1928
TH1.cxx:1929
TH1.cxx:1930
TH1.cxx:1931
TH1.cxx:1932
TH1.cxx:1933
TH1.cxx:1934
TH1.cxx:1935
TH1.cxx:1936
TH1.cxx:1937
TH1.cxx:1938
TH1.cxx:1939
TH1.cxx:1940
TH1.cxx:1941
TH1.cxx:1942
TH1.cxx:1943
TH1.cxx:1944
TH1.cxx:1945
TH1.cxx:1946
TH1.cxx:1947
TH1.cxx:1948
TH1.cxx:1949
TH1.cxx:1950
TH1.cxx:1951
TH1.cxx:1952
TH1.cxx:1953
TH1.cxx:1954
TH1.cxx:1955
TH1.cxx:1956
TH1.cxx:1957
TH1.cxx:1958
TH1.cxx:1959
TH1.cxx:1960
TH1.cxx:1961
TH1.cxx:1962
TH1.cxx:1963
TH1.cxx:1964
TH1.cxx:1965
TH1.cxx:1966
TH1.cxx:1967
TH1.cxx:1968
TH1.cxx:1969
TH1.cxx:1970
TH1.cxx:1971
TH1.cxx:1972
TH1.cxx:1973
TH1.cxx:1974
TH1.cxx:1975
TH1.cxx:1976
TH1.cxx:1977
TH1.cxx:1978
TH1.cxx:1979
TH1.cxx:1980
TH1.cxx:1981
TH1.cxx:1982
TH1.cxx:1983
TH1.cxx:1984
TH1.cxx:1985
TH1.cxx:1986
TH1.cxx:1987
TH1.cxx:1988
TH1.cxx:1989
TH1.cxx:1990
TH1.cxx:1991
TH1.cxx:1992
TH1.cxx:1993
TH1.cxx:1994
TH1.cxx:1995
TH1.cxx:1996
TH1.cxx:1997
TH1.cxx:1998
TH1.cxx:1999
TH1.cxx:2000
TH1.cxx:2001
TH1.cxx:2002
TH1.cxx:2003
TH1.cxx:2004
TH1.cxx:2005
TH1.cxx:2006
TH1.cxx:2007
TH1.cxx:2008
TH1.cxx:2009
TH1.cxx:2010
TH1.cxx:2011
TH1.cxx:2012
TH1.cxx:2013
TH1.cxx:2014
TH1.cxx:2015
TH1.cxx:2016
TH1.cxx:2017
TH1.cxx:2018
TH1.cxx:2019
TH1.cxx:2020
TH1.cxx:2021
TH1.cxx:2022
TH1.cxx:2023
TH1.cxx:2024
TH1.cxx:2025
TH1.cxx:2026
TH1.cxx:2027
TH1.cxx:2028
TH1.cxx:2029
TH1.cxx:2030
TH1.cxx:2031
TH1.cxx:2032
TH1.cxx:2033
TH1.cxx:2034
TH1.cxx:2035
TH1.cxx:2036
TH1.cxx:2037
TH1.cxx:2038
TH1.cxx:2039
TH1.cxx:2040
TH1.cxx:2041
TH1.cxx:2042
TH1.cxx:2043
TH1.cxx:2044
TH1.cxx:2045
TH1.cxx:2046
TH1.cxx:2047
TH1.cxx:2048
TH1.cxx:2049
TH1.cxx:2050
TH1.cxx:2051
TH1.cxx:2052
TH1.cxx:2053
TH1.cxx:2054
TH1.cxx:2055
TH1.cxx:2056
TH1.cxx:2057
TH1.cxx:2058
TH1.cxx:2059
TH1.cxx:2060
TH1.cxx:2061
TH1.cxx:2062
TH1.cxx:2063
TH1.cxx:2064
TH1.cxx:2065
TH1.cxx:2066
TH1.cxx:2067
TH1.cxx:2068
TH1.cxx:2069
TH1.cxx:2070
TH1.cxx:2071
TH1.cxx:2072
TH1.cxx:2073
TH1.cxx:2074
TH1.cxx:2075
TH1.cxx:2076
TH1.cxx:2077
TH1.cxx:2078
TH1.cxx:2079
TH1.cxx:2080
TH1.cxx:2081
TH1.cxx:2082
TH1.cxx:2083
TH1.cxx:2084
TH1.cxx:2085
TH1.cxx:2086
TH1.cxx:2087
TH1.cxx:2088
TH1.cxx:2089
TH1.cxx:2090
TH1.cxx:2091
TH1.cxx:2092
TH1.cxx:2093
TH1.cxx:2094
TH1.cxx:2095
TH1.cxx:2096
TH1.cxx:2097
TH1.cxx:2098
TH1.cxx:2099
TH1.cxx:2100
TH1.cxx:2101
TH1.cxx:2102
TH1.cxx:2103
TH1.cxx:2104
TH1.cxx:2105
TH1.cxx:2106
TH1.cxx:2107
TH1.cxx:2108
TH1.cxx:2109
TH1.cxx:2110
TH1.cxx:2111
TH1.cxx:2112
TH1.cxx:2113
TH1.cxx:2114
TH1.cxx:2115
TH1.cxx:2116
TH1.cxx:2117
TH1.cxx:2118
TH1.cxx:2119
TH1.cxx:2120
TH1.cxx:2121
TH1.cxx:2122
TH1.cxx:2123
TH1.cxx:2124
TH1.cxx:2125
TH1.cxx:2126
TH1.cxx:2127
TH1.cxx:2128
TH1.cxx:2129
TH1.cxx:2130
TH1.cxx:2131
TH1.cxx:2132
TH1.cxx:2133
TH1.cxx:2134
TH1.cxx:2135
TH1.cxx:2136
TH1.cxx:2137
TH1.cxx:2138
TH1.cxx:2139
TH1.cxx:2140
TH1.cxx:2141
TH1.cxx:2142
TH1.cxx:2143
TH1.cxx:2144
TH1.cxx:2145
TH1.cxx:2146
TH1.cxx:2147
TH1.cxx:2148
TH1.cxx:2149
TH1.cxx:2150
TH1.cxx:2151
TH1.cxx:2152
TH1.cxx:2153
TH1.cxx:2154
TH1.cxx:2155
TH1.cxx:2156
TH1.cxx:2157
TH1.cxx:2158
TH1.cxx:2159
TH1.cxx:2160
TH1.cxx:2161
TH1.cxx:2162
TH1.cxx:2163
TH1.cxx:2164
TH1.cxx:2165
TH1.cxx:2166
TH1.cxx:2167
TH1.cxx:2168
TH1.cxx:2169
TH1.cxx:2170
TH1.cxx:2171
TH1.cxx:2172
TH1.cxx:2173
TH1.cxx:2174
TH1.cxx:2175
TH1.cxx:2176
TH1.cxx:2177
TH1.cxx:2178
TH1.cxx:2179
TH1.cxx:2180
TH1.cxx:2181
TH1.cxx:2182
TH1.cxx:2183
TH1.cxx:2184
TH1.cxx:2185
TH1.cxx:2186
TH1.cxx:2187
TH1.cxx:2188
TH1.cxx:2189
TH1.cxx:2190
TH1.cxx:2191
TH1.cxx:2192
TH1.cxx:2193
TH1.cxx:2194
TH1.cxx:2195
TH1.cxx:2196
TH1.cxx:2197
TH1.cxx:2198
TH1.cxx:2199
TH1.cxx:2200
TH1.cxx:2201
TH1.cxx:2202
TH1.cxx:2203
TH1.cxx:2204
TH1.cxx:2205
TH1.cxx:2206
TH1.cxx:2207
TH1.cxx:2208
TH1.cxx:2209
TH1.cxx:2210
TH1.cxx:2211
TH1.cxx:2212
TH1.cxx:2213
TH1.cxx:2214
TH1.cxx:2215
TH1.cxx:2216
TH1.cxx:2217
TH1.cxx:2218
TH1.cxx:2219
TH1.cxx:2220
TH1.cxx:2221
TH1.cxx:2222
TH1.cxx:2223
TH1.cxx:2224
TH1.cxx:2225
TH1.cxx:2226
TH1.cxx:2227
TH1.cxx:2228
TH1.cxx:2229
TH1.cxx:2230
TH1.cxx:2231
TH1.cxx:2232
TH1.cxx:2233
TH1.cxx:2234
TH1.cxx:2235
TH1.cxx:2236
TH1.cxx:2237
TH1.cxx:2238
TH1.cxx:2239
TH1.cxx:2240
TH1.cxx:2241
TH1.cxx:2242
TH1.cxx:2243
TH1.cxx:2244
TH1.cxx:2245
TH1.cxx:2246
TH1.cxx:2247
TH1.cxx:2248
TH1.cxx:2249
TH1.cxx:2250
TH1.cxx:2251
TH1.cxx:2252
TH1.cxx:2253
TH1.cxx:2254
TH1.cxx:2255
TH1.cxx:2256
TH1.cxx:2257
TH1.cxx:2258
TH1.cxx:2259
TH1.cxx:2260
TH1.cxx:2261
TH1.cxx:2262
TH1.cxx:2263
TH1.cxx:2264
TH1.cxx:2265
TH1.cxx:2266
TH1.cxx:2267
TH1.cxx:2268
TH1.cxx:2269
TH1.cxx:2270
TH1.cxx:2271
TH1.cxx:2272
TH1.cxx:2273
TH1.cxx:2274
TH1.cxx:2275
TH1.cxx:2276
TH1.cxx:2277
TH1.cxx:2278
TH1.cxx:2279
TH1.cxx:2280
TH1.cxx:2281
TH1.cxx:2282
TH1.cxx:2283
TH1.cxx:2284
TH1.cxx:2285
TH1.cxx:2286
TH1.cxx:2287
TH1.cxx:2288
TH1.cxx:2289
TH1.cxx:2290
TH1.cxx:2291
TH1.cxx:2292
TH1.cxx:2293
TH1.cxx:2294
TH1.cxx:2295
TH1.cxx:2296
TH1.cxx:2297
TH1.cxx:2298
TH1.cxx:2299
TH1.cxx:2300
TH1.cxx:2301
TH1.cxx:2302
TH1.cxx:2303
TH1.cxx:2304
TH1.cxx:2305
TH1.cxx:2306
TH1.cxx:2307
TH1.cxx:2308
TH1.cxx:2309
TH1.cxx:2310
TH1.cxx:2311
TH1.cxx:2312
TH1.cxx:2313
TH1.cxx:2314
TH1.cxx:2315
TH1.cxx:2316
TH1.cxx:2317
TH1.cxx:2318
TH1.cxx:2319
TH1.cxx:2320
TH1.cxx:2321
TH1.cxx:2322
TH1.cxx:2323
TH1.cxx:2324
TH1.cxx:2325
TH1.cxx:2326
TH1.cxx:2327
TH1.cxx:2328
TH1.cxx:2329
TH1.cxx:2330
TH1.cxx:2331
TH1.cxx:2332
TH1.cxx:2333
TH1.cxx:2334
TH1.cxx:2335
TH1.cxx:2336
TH1.cxx:2337
TH1.cxx:2338
TH1.cxx:2339
TH1.cxx:2340
TH1.cxx:2341
TH1.cxx:2342
TH1.cxx:2343
TH1.cxx:2344
TH1.cxx:2345
TH1.cxx:2346
TH1.cxx:2347
TH1.cxx:2348
TH1.cxx:2349
TH1.cxx:2350
TH1.cxx:2351
TH1.cxx:2352
TH1.cxx:2353
TH1.cxx:2354
TH1.cxx:2355
TH1.cxx:2356
TH1.cxx:2357
TH1.cxx:2358
TH1.cxx:2359
TH1.cxx:2360
TH1.cxx:2361
TH1.cxx:2362
TH1.cxx:2363
TH1.cxx:2364
TH1.cxx:2365
TH1.cxx:2366
TH1.cxx:2367
TH1.cxx:2368
TH1.cxx:2369
TH1.cxx:2370
TH1.cxx:2371
TH1.cxx:2372
TH1.cxx:2373
TH1.cxx:2374
TH1.cxx:2375
TH1.cxx:2376
TH1.cxx:2377
TH1.cxx:2378
TH1.cxx:2379
TH1.cxx:2380
TH1.cxx:2381
TH1.cxx:2382
TH1.cxx:2383
TH1.cxx:2384
TH1.cxx:2385
TH1.cxx:2386
TH1.cxx:2387
TH1.cxx:2388
TH1.cxx:2389
TH1.cxx:2390
TH1.cxx:2391
TH1.cxx:2392
TH1.cxx:2393
TH1.cxx:2394
TH1.cxx:2395
TH1.cxx:2396
TH1.cxx:2397
TH1.cxx:2398
TH1.cxx:2399
TH1.cxx:2400
TH1.cxx:2401
TH1.cxx:2402
TH1.cxx:2403
TH1.cxx:2404
TH1.cxx:2405
TH1.cxx:2406
TH1.cxx:2407
TH1.cxx:2408
TH1.cxx:2409
TH1.cxx:2410
TH1.cxx:2411
TH1.cxx:2412
TH1.cxx:2413
TH1.cxx:2414
TH1.cxx:2415
TH1.cxx:2416
TH1.cxx:2417
TH1.cxx:2418
TH1.cxx:2419
TH1.cxx:2420
TH1.cxx:2421
TH1.cxx:2422
TH1.cxx:2423
TH1.cxx:2424
TH1.cxx:2425
TH1.cxx:2426
TH1.cxx:2427
TH1.cxx:2428
TH1.cxx:2429
TH1.cxx:2430
TH1.cxx:2431
TH1.cxx:2432
TH1.cxx:2433
TH1.cxx:2434
TH1.cxx:2435
TH1.cxx:2436
TH1.cxx:2437
TH1.cxx:2438
TH1.cxx:2439
TH1.cxx:2440
TH1.cxx:2441
TH1.cxx:2442
TH1.cxx:2443
TH1.cxx:2444
TH1.cxx:2445
TH1.cxx:2446
TH1.cxx:2447
TH1.cxx:2448
TH1.cxx:2449
TH1.cxx:2450
TH1.cxx:2451
TH1.cxx:2452
TH1.cxx:2453
TH1.cxx:2454
TH1.cxx:2455
TH1.cxx:2456
TH1.cxx:2457
TH1.cxx:2458
TH1.cxx:2459
TH1.cxx:2460
TH1.cxx:2461
TH1.cxx:2462
TH1.cxx:2463
TH1.cxx:2464
TH1.cxx:2465
TH1.cxx:2466
TH1.cxx:2467
TH1.cxx:2468
TH1.cxx:2469
TH1.cxx:2470
TH1.cxx:2471
TH1.cxx:2472
TH1.cxx:2473
TH1.cxx:2474
TH1.cxx:2475
TH1.cxx:2476
TH1.cxx:2477
TH1.cxx:2478
TH1.cxx:2479
TH1.cxx:2480
TH1.cxx:2481
TH1.cxx:2482
TH1.cxx:2483
TH1.cxx:2484
TH1.cxx:2485
TH1.cxx:2486
TH1.cxx:2487
TH1.cxx:2488
TH1.cxx:2489
TH1.cxx:2490
TH1.cxx:2491
TH1.cxx:2492
TH1.cxx:2493
TH1.cxx:2494
TH1.cxx:2495
TH1.cxx:2496
TH1.cxx:2497
TH1.cxx:2498
TH1.cxx:2499
TH1.cxx:2500
TH1.cxx:2501
TH1.cxx:2502
TH1.cxx:2503
TH1.cxx:2504
TH1.cxx:2505
TH1.cxx:2506
TH1.cxx:2507
TH1.cxx:2508
TH1.cxx:2509
TH1.cxx:2510
TH1.cxx:2511
TH1.cxx:2512
TH1.cxx:2513
TH1.cxx:2514
TH1.cxx:2515
TH1.cxx:2516
TH1.cxx:2517
TH1.cxx:2518
TH1.cxx:2519
TH1.cxx:2520
TH1.cxx:2521
TH1.cxx:2522
TH1.cxx:2523
TH1.cxx:2524
TH1.cxx:2525
TH1.cxx:2526
TH1.cxx:2527
TH1.cxx:2528
TH1.cxx:2529
TH1.cxx:2530
TH1.cxx:2531
TH1.cxx:2532
TH1.cxx:2533
TH1.cxx:2534
TH1.cxx:2535
TH1.cxx:2536
TH1.cxx:2537
TH1.cxx:2538
TH1.cxx:2539
TH1.cxx:2540
TH1.cxx:2541
TH1.cxx:2542
TH1.cxx:2543
TH1.cxx:2544
TH1.cxx:2545
TH1.cxx:2546
TH1.cxx:2547
TH1.cxx:2548
TH1.cxx:2549
TH1.cxx:2550
TH1.cxx:2551
TH1.cxx:2552
TH1.cxx:2553
TH1.cxx:2554
TH1.cxx:2555
TH1.cxx:2556
TH1.cxx:2557
TH1.cxx:2558
TH1.cxx:2559
TH1.cxx:2560
TH1.cxx:2561
TH1.cxx:2562
TH1.cxx:2563
TH1.cxx:2564
TH1.cxx:2565
TH1.cxx:2566
TH1.cxx:2567
TH1.cxx:2568
TH1.cxx:2569
TH1.cxx:2570
TH1.cxx:2571
TH1.cxx:2572
TH1.cxx:2573
TH1.cxx:2574
TH1.cxx:2575
TH1.cxx:2576
TH1.cxx:2577
TH1.cxx:2578
TH1.cxx:2579
TH1.cxx:2580
TH1.cxx:2581
TH1.cxx:2582
TH1.cxx:2583
TH1.cxx:2584
TH1.cxx:2585
TH1.cxx:2586
TH1.cxx:2587
TH1.cxx:2588
TH1.cxx:2589
TH1.cxx:2590
TH1.cxx:2591
TH1.cxx:2592
TH1.cxx:2593
TH1.cxx:2594
TH1.cxx:2595
TH1.cxx:2596
TH1.cxx:2597
TH1.cxx:2598
TH1.cxx:2599
TH1.cxx:2600
TH1.cxx:2601
TH1.cxx:2602
TH1.cxx:2603
TH1.cxx:2604
TH1.cxx:2605
TH1.cxx:2606
TH1.cxx:2607
TH1.cxx:2608
TH1.cxx:2609
TH1.cxx:2610
TH1.cxx:2611
TH1.cxx:2612
TH1.cxx:2613
TH1.cxx:2614
TH1.cxx:2615
TH1.cxx:2616
TH1.cxx:2617
TH1.cxx:2618
TH1.cxx:2619
TH1.cxx:2620
TH1.cxx:2621
TH1.cxx:2622
TH1.cxx:2623
TH1.cxx:2624
TH1.cxx:2625
TH1.cxx:2626
TH1.cxx:2627
TH1.cxx:2628
TH1.cxx:2629
TH1.cxx:2630
TH1.cxx:2631
TH1.cxx:2632
TH1.cxx:2633
TH1.cxx:2634
TH1.cxx:2635
TH1.cxx:2636
TH1.cxx:2637
TH1.cxx:2638
TH1.cxx:2639
TH1.cxx:2640
TH1.cxx:2641
TH1.cxx:2642
TH1.cxx:2643
TH1.cxx:2644
TH1.cxx:2645
TH1.cxx:2646
TH1.cxx:2647
TH1.cxx:2648
TH1.cxx:2649
TH1.cxx:2650
TH1.cxx:2651
TH1.cxx:2652
TH1.cxx:2653
TH1.cxx:2654
TH1.cxx:2655
TH1.cxx:2656
TH1.cxx:2657
TH1.cxx:2658
TH1.cxx:2659
TH1.cxx:2660
TH1.cxx:2661
TH1.cxx:2662
TH1.cxx:2663
TH1.cxx:2664
TH1.cxx:2665
TH1.cxx:2666
TH1.cxx:2667
TH1.cxx:2668
TH1.cxx:2669
TH1.cxx:2670
TH1.cxx:2671
TH1.cxx:2672
TH1.cxx:2673
TH1.cxx:2674
TH1.cxx:2675
TH1.cxx:2676
TH1.cxx:2677
TH1.cxx:2678
TH1.cxx:2679
TH1.cxx:2680
TH1.cxx:2681
TH1.cxx:2682
TH1.cxx:2683
TH1.cxx:2684
TH1.cxx:2685
TH1.cxx:2686
TH1.cxx:2687
TH1.cxx:2688
TH1.cxx:2689
TH1.cxx:2690
TH1.cxx:2691
TH1.cxx:2692
TH1.cxx:2693
TH1.cxx:2694
TH1.cxx:2695
TH1.cxx:2696
TH1.cxx:2697
TH1.cxx:2698
TH1.cxx:2699
TH1.cxx:2700
TH1.cxx:2701
TH1.cxx:2702
TH1.cxx:2703
TH1.cxx:2704
TH1.cxx:2705
TH1.cxx:2706
TH1.cxx:2707
TH1.cxx:2708
TH1.cxx:2709
TH1.cxx:2710
TH1.cxx:2711
TH1.cxx:2712
TH1.cxx:2713
TH1.cxx:2714
TH1.cxx:2715
TH1.cxx:2716
TH1.cxx:2717
TH1.cxx:2718
TH1.cxx:2719
TH1.cxx:2720
TH1.cxx:2721
TH1.cxx:2722
TH1.cxx:2723
TH1.cxx:2724
TH1.cxx:2725
TH1.cxx:2726
TH1.cxx:2727
TH1.cxx:2728
TH1.cxx:2729
TH1.cxx:2730
TH1.cxx:2731
TH1.cxx:2732
TH1.cxx:2733
TH1.cxx:2734
TH1.cxx:2735
TH1.cxx:2736
TH1.cxx:2737
TH1.cxx:2738
TH1.cxx:2739
TH1.cxx:2740
TH1.cxx:2741
TH1.cxx:2742
TH1.cxx:2743
TH1.cxx:2744
TH1.cxx:2745
TH1.cxx:2746
TH1.cxx:2747
TH1.cxx:2748
TH1.cxx:2749
TH1.cxx:2750
TH1.cxx:2751
TH1.cxx:2752
TH1.cxx:2753
TH1.cxx:2754
TH1.cxx:2755
TH1.cxx:2756
TH1.cxx:2757
TH1.cxx:2758
TH1.cxx:2759
TH1.cxx:2760
TH1.cxx:2761
TH1.cxx:2762
TH1.cxx:2763
TH1.cxx:2764
TH1.cxx:2765
TH1.cxx:2766
TH1.cxx:2767
TH1.cxx:2768
TH1.cxx:2769
TH1.cxx:2770
TH1.cxx:2771
TH1.cxx:2772
TH1.cxx:2773
TH1.cxx:2774
TH1.cxx:2775
TH1.cxx:2776
TH1.cxx:2777
TH1.cxx:2778
TH1.cxx:2779
TH1.cxx:2780
TH1.cxx:2781
TH1.cxx:2782
TH1.cxx:2783
TH1.cxx:2784
TH1.cxx:2785
TH1.cxx:2786
TH1.cxx:2787
TH1.cxx:2788
TH1.cxx:2789
TH1.cxx:2790
TH1.cxx:2791
TH1.cxx:2792
TH1.cxx:2793
TH1.cxx:2794
TH1.cxx:2795
TH1.cxx:2796
TH1.cxx:2797
TH1.cxx:2798
TH1.cxx:2799
TH1.cxx:2800
TH1.cxx:2801
TH1.cxx:2802
TH1.cxx:2803
TH1.cxx:2804
TH1.cxx:2805
TH1.cxx:2806
TH1.cxx:2807
TH1.cxx:2808
TH1.cxx:2809
TH1.cxx:2810
TH1.cxx:2811
TH1.cxx:2812
TH1.cxx:2813
TH1.cxx:2814
TH1.cxx:2815
TH1.cxx:2816
TH1.cxx:2817
TH1.cxx:2818
TH1.cxx:2819
TH1.cxx:2820
TH1.cxx:2821
TH1.cxx:2822
TH1.cxx:2823
TH1.cxx:2824
TH1.cxx:2825
TH1.cxx:2826
TH1.cxx:2827
TH1.cxx:2828
TH1.cxx:2829
TH1.cxx:2830
TH1.cxx:2831
TH1.cxx:2832
TH1.cxx:2833
TH1.cxx:2834
TH1.cxx:2835
TH1.cxx:2836
TH1.cxx:2837
TH1.cxx:2838
TH1.cxx:2839
TH1.cxx:2840
TH1.cxx:2841
TH1.cxx:2842
TH1.cxx:2843
TH1.cxx:2844
TH1.cxx:2845
TH1.cxx:2846
TH1.cxx:2847
TH1.cxx:2848
TH1.cxx:2849
TH1.cxx:2850
TH1.cxx:2851
TH1.cxx:2852
TH1.cxx:2853
TH1.cxx:2854
TH1.cxx:2855
TH1.cxx:2856
TH1.cxx:2857
TH1.cxx:2858
TH1.cxx:2859
TH1.cxx:2860
TH1.cxx:2861
TH1.cxx:2862
TH1.cxx:2863
TH1.cxx:2864
TH1.cxx:2865
TH1.cxx:2866
TH1.cxx:2867
TH1.cxx:2868
TH1.cxx:2869
TH1.cxx:2870
TH1.cxx:2871
TH1.cxx:2872
TH1.cxx:2873
TH1.cxx:2874
TH1.cxx:2875
TH1.cxx:2876
TH1.cxx:2877
TH1.cxx:2878
TH1.cxx:2879
TH1.cxx:2880
TH1.cxx:2881
TH1.cxx:2882
TH1.cxx:2883
TH1.cxx:2884
TH1.cxx:2885
TH1.cxx:2886
TH1.cxx:2887
TH1.cxx:2888
TH1.cxx:2889
TH1.cxx:2890
TH1.cxx:2891
TH1.cxx:2892
TH1.cxx:2893
TH1.cxx:2894
TH1.cxx:2895
TH1.cxx:2896
TH1.cxx:2897
TH1.cxx:2898
TH1.cxx:2899
TH1.cxx:2900
TH1.cxx:2901
TH1.cxx:2902
TH1.cxx:2903
TH1.cxx:2904
TH1.cxx:2905
TH1.cxx:2906
TH1.cxx:2907
TH1.cxx:2908
TH1.cxx:2909
TH1.cxx:2910
TH1.cxx:2911
TH1.cxx:2912
TH1.cxx:2913
TH1.cxx:2914
TH1.cxx:2915
TH1.cxx:2916
TH1.cxx:2917
TH1.cxx:2918
TH1.cxx:2919
TH1.cxx:2920
TH1.cxx:2921
TH1.cxx:2922
TH1.cxx:2923
TH1.cxx:2924
TH1.cxx:2925
TH1.cxx:2926
TH1.cxx:2927
TH1.cxx:2928
TH1.cxx:2929
TH1.cxx:2930
TH1.cxx:2931
TH1.cxx:2932
TH1.cxx:2933
TH1.cxx:2934
TH1.cxx:2935
TH1.cxx:2936
TH1.cxx:2937
TH1.cxx:2938
TH1.cxx:2939
TH1.cxx:2940
TH1.cxx:2941
TH1.cxx:2942
TH1.cxx:2943
TH1.cxx:2944
TH1.cxx:2945
TH1.cxx:2946
TH1.cxx:2947
TH1.cxx:2948
TH1.cxx:2949
TH1.cxx:2950
TH1.cxx:2951
TH1.cxx:2952
TH1.cxx:2953
TH1.cxx:2954
TH1.cxx:2955
TH1.cxx:2956
TH1.cxx:2957
TH1.cxx:2958
TH1.cxx:2959
TH1.cxx:2960
TH1.cxx:2961
TH1.cxx:2962
TH1.cxx:2963
TH1.cxx:2964
TH1.cxx:2965
TH1.cxx:2966
TH1.cxx:2967
TH1.cxx:2968
TH1.cxx:2969
TH1.cxx:2970
TH1.cxx:2971
TH1.cxx:2972
TH1.cxx:2973
TH1.cxx:2974
TH1.cxx:2975
TH1.cxx:2976
TH1.cxx:2977
TH1.cxx:2978
TH1.cxx:2979
TH1.cxx:2980
TH1.cxx:2981
TH1.cxx:2982
TH1.cxx:2983
TH1.cxx:2984
TH1.cxx:2985
TH1.cxx:2986
TH1.cxx:2987
TH1.cxx:2988
TH1.cxx:2989
TH1.cxx:2990
TH1.cxx:2991
TH1.cxx:2992
TH1.cxx:2993
TH1.cxx:2994
TH1.cxx:2995
TH1.cxx:2996
TH1.cxx:2997
TH1.cxx:2998
TH1.cxx:2999
TH1.cxx:3000
TH1.cxx:3001
TH1.cxx:3002
TH1.cxx:3003
TH1.cxx:3004
TH1.cxx:3005
TH1.cxx:3006
TH1.cxx:3007
TH1.cxx:3008
TH1.cxx:3009
TH1.cxx:3010
TH1.cxx:3011
TH1.cxx:3012
TH1.cxx:3013
TH1.cxx:3014
TH1.cxx:3015
TH1.cxx:3016
TH1.cxx:3017
TH1.cxx:3018
TH1.cxx:3019
TH1.cxx:3020
TH1.cxx:3021
TH1.cxx:3022
TH1.cxx:3023
TH1.cxx:3024
TH1.cxx:3025
TH1.cxx:3026
TH1.cxx:3027
TH1.cxx:3028
TH1.cxx:3029
TH1.cxx:3030
TH1.cxx:3031
TH1.cxx:3032
TH1.cxx:3033
TH1.cxx:3034
TH1.cxx:3035
TH1.cxx:3036
TH1.cxx:3037
TH1.cxx:3038
TH1.cxx:3039
TH1.cxx:3040
TH1.cxx:3041
TH1.cxx:3042
TH1.cxx:3043
TH1.cxx:3044
TH1.cxx:3045
TH1.cxx:3046
TH1.cxx:3047
TH1.cxx:3048
TH1.cxx:3049
TH1.cxx:3050
TH1.cxx:3051
TH1.cxx:3052
TH1.cxx:3053
TH1.cxx:3054
TH1.cxx:3055
TH1.cxx:3056
TH1.cxx:3057
TH1.cxx:3058
TH1.cxx:3059
TH1.cxx:3060
TH1.cxx:3061
TH1.cxx:3062
TH1.cxx:3063
TH1.cxx:3064
TH1.cxx:3065
TH1.cxx:3066
TH1.cxx:3067
TH1.cxx:3068
TH1.cxx:3069
TH1.cxx:3070
TH1.cxx:3071
TH1.cxx:3072
TH1.cxx:3073
TH1.cxx:3074
TH1.cxx:3075
TH1.cxx:3076
TH1.cxx:3077
TH1.cxx:3078
TH1.cxx:3079
TH1.cxx:3080
TH1.cxx:3081
TH1.cxx:3082
TH1.cxx:3083
TH1.cxx:3084
TH1.cxx:3085
TH1.cxx:3086
TH1.cxx:3087
TH1.cxx:3088
TH1.cxx:3089
TH1.cxx:3090
TH1.cxx:3091
TH1.cxx:3092
TH1.cxx:3093
TH1.cxx:3094
TH1.cxx:3095
TH1.cxx:3096
TH1.cxx:3097
TH1.cxx:3098
TH1.cxx:3099
TH1.cxx:3100
TH1.cxx:3101
TH1.cxx:3102
TH1.cxx:3103
TH1.cxx:3104
TH1.cxx:3105
TH1.cxx:3106
TH1.cxx:3107
TH1.cxx:3108
TH1.cxx:3109
TH1.cxx:3110
TH1.cxx:3111
TH1.cxx:3112
TH1.cxx:3113
TH1.cxx:3114
TH1.cxx:3115
TH1.cxx:3116
TH1.cxx:3117
TH1.cxx:3118
TH1.cxx:3119
TH1.cxx:3120
TH1.cxx:3121
TH1.cxx:3122
TH1.cxx:3123
TH1.cxx:3124
TH1.cxx:3125
TH1.cxx:3126
TH1.cxx:3127
TH1.cxx:3128
TH1.cxx:3129
TH1.cxx:3130
TH1.cxx:3131
TH1.cxx:3132
TH1.cxx:3133
TH1.cxx:3134
TH1.cxx:3135
TH1.cxx:3136
TH1.cxx:3137
TH1.cxx:3138
TH1.cxx:3139
TH1.cxx:3140
TH1.cxx:3141
TH1.cxx:3142
TH1.cxx:3143
TH1.cxx:3144
TH1.cxx:3145
TH1.cxx:3146
TH1.cxx:3147
TH1.cxx:3148
TH1.cxx:3149
TH1.cxx:3150
TH1.cxx:3151
TH1.cxx:3152
TH1.cxx:3153
TH1.cxx:3154
TH1.cxx:3155
TH1.cxx:3156
TH1.cxx:3157
TH1.cxx:3158
TH1.cxx:3159
TH1.cxx:3160
TH1.cxx:3161
TH1.cxx:3162
TH1.cxx:3163
TH1.cxx:3164
TH1.cxx:3165
TH1.cxx:3166
TH1.cxx:3167
TH1.cxx:3168
TH1.cxx:3169
TH1.cxx:3170
TH1.cxx:3171
TH1.cxx:3172
TH1.cxx:3173
TH1.cxx:3174
TH1.cxx:3175
TH1.cxx:3176
TH1.cxx:3177
TH1.cxx:3178
TH1.cxx:3179
TH1.cxx:3180
TH1.cxx:3181
TH1.cxx:3182
TH1.cxx:3183
TH1.cxx:3184
TH1.cxx:3185
TH1.cxx:3186
TH1.cxx:3187
TH1.cxx:3188
TH1.cxx:3189
TH1.cxx:3190
TH1.cxx:3191
TH1.cxx:3192
TH1.cxx:3193
TH1.cxx:3194
TH1.cxx:3195
TH1.cxx:3196
TH1.cxx:3197
TH1.cxx:3198
TH1.cxx:3199
TH1.cxx:3200
TH1.cxx:3201
TH1.cxx:3202
TH1.cxx:3203
TH1.cxx:3204
TH1.cxx:3205
TH1.cxx:3206
TH1.cxx:3207
TH1.cxx:3208
TH1.cxx:3209
TH1.cxx:3210
TH1.cxx:3211
TH1.cxx:3212
TH1.cxx:3213
TH1.cxx:3214
TH1.cxx:3215
TH1.cxx:3216
TH1.cxx:3217
TH1.cxx:3218
TH1.cxx:3219
TH1.cxx:3220
TH1.cxx:3221
TH1.cxx:3222
TH1.cxx:3223
TH1.cxx:3224
TH1.cxx:3225
TH1.cxx:3226
TH1.cxx:3227
TH1.cxx:3228
TH1.cxx:3229
TH1.cxx:3230
TH1.cxx:3231
TH1.cxx:3232
TH1.cxx:3233
TH1.cxx:3234
TH1.cxx:3235
TH1.cxx:3236
TH1.cxx:3237
TH1.cxx:3238
TH1.cxx:3239
TH1.cxx:3240
TH1.cxx:3241
TH1.cxx:3242
TH1.cxx:3243
TH1.cxx:3244
TH1.cxx:3245
TH1.cxx:3246
TH1.cxx:3247
TH1.cxx:3248
TH1.cxx:3249
TH1.cxx:3250
TH1.cxx:3251
TH1.cxx:3252
TH1.cxx:3253
TH1.cxx:3254
TH1.cxx:3255
TH1.cxx:3256
TH1.cxx:3257
TH1.cxx:3258
TH1.cxx:3259
TH1.cxx:3260
TH1.cxx:3261
TH1.cxx:3262
TH1.cxx:3263
TH1.cxx:3264
TH1.cxx:3265
TH1.cxx:3266
TH1.cxx:3267
TH1.cxx:3268
TH1.cxx:3269
TH1.cxx:3270
TH1.cxx:3271
TH1.cxx:3272
TH1.cxx:3273
TH1.cxx:3274
TH1.cxx:3275
TH1.cxx:3276
TH1.cxx:3277
TH1.cxx:3278
TH1.cxx:3279
TH1.cxx:3280
TH1.cxx:3281
TH1.cxx:3282
TH1.cxx:3283
TH1.cxx:3284
TH1.cxx:3285
TH1.cxx:3286
TH1.cxx:3287
TH1.cxx:3288
TH1.cxx:3289
TH1.cxx:3290
TH1.cxx:3291
TH1.cxx:3292
TH1.cxx:3293
TH1.cxx:3294
TH1.cxx:3295
TH1.cxx:3296
TH1.cxx:3297
TH1.cxx:3298
TH1.cxx:3299
TH1.cxx:3300
TH1.cxx:3301
TH1.cxx:3302
TH1.cxx:3303
TH1.cxx:3304
TH1.cxx:3305
TH1.cxx:3306
TH1.cxx:3307
TH1.cxx:3308
TH1.cxx:3309
TH1.cxx:3310
TH1.cxx:3311
TH1.cxx:3312
TH1.cxx:3313
TH1.cxx:3314
TH1.cxx:3315
TH1.cxx:3316
TH1.cxx:3317
TH1.cxx:3318
TH1.cxx:3319
TH1.cxx:3320
TH1.cxx:3321
TH1.cxx:3322
TH1.cxx:3323
TH1.cxx:3324
TH1.cxx:3325
TH1.cxx:3326
TH1.cxx:3327
TH1.cxx:3328
TH1.cxx:3329
TH1.cxx:3330
TH1.cxx:3331
TH1.cxx:3332
TH1.cxx:3333
TH1.cxx:3334
TH1.cxx:3335
TH1.cxx:3336
TH1.cxx:3337
TH1.cxx:3338
TH1.cxx:3339
TH1.cxx:3340
TH1.cxx:3341
TH1.cxx:3342
TH1.cxx:3343
TH1.cxx:3344
TH1.cxx:3345
TH1.cxx:3346
TH1.cxx:3347
TH1.cxx:3348
TH1.cxx:3349
TH1.cxx:3350
TH1.cxx:3351
TH1.cxx:3352
TH1.cxx:3353
TH1.cxx:3354
TH1.cxx:3355
TH1.cxx:3356
TH1.cxx:3357
TH1.cxx:3358
TH1.cxx:3359
TH1.cxx:3360
TH1.cxx:3361
TH1.cxx:3362
TH1.cxx:3363
TH1.cxx:3364
TH1.cxx:3365
TH1.cxx:3366
TH1.cxx:3367
TH1.cxx:3368
TH1.cxx:3369
TH1.cxx:3370
TH1.cxx:3371
TH1.cxx:3372
TH1.cxx:3373
TH1.cxx:3374
TH1.cxx:3375
TH1.cxx:3376
TH1.cxx:3377
TH1.cxx:3378
TH1.cxx:3379
TH1.cxx:3380
TH1.cxx:3381
TH1.cxx:3382
TH1.cxx:3383
TH1.cxx:3384
TH1.cxx:3385
TH1.cxx:3386
TH1.cxx:3387
TH1.cxx:3388
TH1.cxx:3389
TH1.cxx:3390
TH1.cxx:3391
TH1.cxx:3392
TH1.cxx:3393
TH1.cxx:3394
TH1.cxx:3395
TH1.cxx:3396
TH1.cxx:3397
TH1.cxx:3398
TH1.cxx:3399
TH1.cxx:3400
TH1.cxx:3401
TH1.cxx:3402
TH1.cxx:3403
TH1.cxx:3404
TH1.cxx:3405
TH1.cxx:3406
TH1.cxx:3407
TH1.cxx:3408
TH1.cxx:3409
TH1.cxx:3410
TH1.cxx:3411
TH1.cxx:3412
TH1.cxx:3413
TH1.cxx:3414
TH1.cxx:3415
TH1.cxx:3416
TH1.cxx:3417
TH1.cxx:3418
TH1.cxx:3419
TH1.cxx:3420
TH1.cxx:3421
TH1.cxx:3422
TH1.cxx:3423
TH1.cxx:3424
TH1.cxx:3425
TH1.cxx:3426
TH1.cxx:3427
TH1.cxx:3428
TH1.cxx:3429
TH1.cxx:3430
TH1.cxx:3431
TH1.cxx:3432
TH1.cxx:3433
TH1.cxx:3434
TH1.cxx:3435
TH1.cxx:3436
TH1.cxx:3437
TH1.cxx:3438
TH1.cxx:3439
TH1.cxx:3440
TH1.cxx:3441
TH1.cxx:3442
TH1.cxx:3443
TH1.cxx:3444
TH1.cxx:3445
TH1.cxx:3446
TH1.cxx:3447
TH1.cxx:3448
TH1.cxx:3449
TH1.cxx:3450
TH1.cxx:3451
TH1.cxx:3452
TH1.cxx:3453
TH1.cxx:3454
TH1.cxx:3455
TH1.cxx:3456
TH1.cxx:3457
TH1.cxx:3458
TH1.cxx:3459
TH1.cxx:3460
TH1.cxx:3461
TH1.cxx:3462
TH1.cxx:3463
TH1.cxx:3464
TH1.cxx:3465
TH1.cxx:3466
TH1.cxx:3467
TH1.cxx:3468
TH1.cxx:3469
TH1.cxx:3470
TH1.cxx:3471
TH1.cxx:3472
TH1.cxx:3473
TH1.cxx:3474
TH1.cxx:3475
TH1.cxx:3476
TH1.cxx:3477
TH1.cxx:3478
TH1.cxx:3479
TH1.cxx:3480
TH1.cxx:3481
TH1.cxx:3482
TH1.cxx:3483
TH1.cxx:3484
TH1.cxx:3485
TH1.cxx:3486
TH1.cxx:3487
TH1.cxx:3488
TH1.cxx:3489
TH1.cxx:3490
TH1.cxx:3491
TH1.cxx:3492
TH1.cxx:3493
TH1.cxx:3494
TH1.cxx:3495
TH1.cxx:3496
TH1.cxx:3497
TH1.cxx:3498
TH1.cxx:3499
TH1.cxx:3500
TH1.cxx:3501
TH1.cxx:3502
TH1.cxx:3503
TH1.cxx:3504
TH1.cxx:3505
TH1.cxx:3506
TH1.cxx:3507
TH1.cxx:3508
TH1.cxx:3509
TH1.cxx:3510
TH1.cxx:3511
TH1.cxx:3512
TH1.cxx:3513
TH1.cxx:3514
TH1.cxx:3515
TH1.cxx:3516
TH1.cxx:3517
TH1.cxx:3518
TH1.cxx:3519
TH1.cxx:3520
TH1.cxx:3521
TH1.cxx:3522
TH1.cxx:3523
TH1.cxx:3524
TH1.cxx:3525
TH1.cxx:3526
TH1.cxx:3527
TH1.cxx:3528
TH1.cxx:3529
TH1.cxx:3530
TH1.cxx:3531
TH1.cxx:3532
TH1.cxx:3533
TH1.cxx:3534
TH1.cxx:3535
TH1.cxx:3536
TH1.cxx:3537
TH1.cxx:3538
TH1.cxx:3539
TH1.cxx:3540
TH1.cxx:3541
TH1.cxx:3542
TH1.cxx:3543
TH1.cxx:3544
TH1.cxx:3545
TH1.cxx:3546
TH1.cxx:3547
TH1.cxx:3548
TH1.cxx:3549
TH1.cxx:3550
TH1.cxx:3551
TH1.cxx:3552
TH1.cxx:3553
TH1.cxx:3554
TH1.cxx:3555
TH1.cxx:3556
TH1.cxx:3557
TH1.cxx:3558
TH1.cxx:3559
TH1.cxx:3560
TH1.cxx:3561
TH1.cxx:3562
TH1.cxx:3563
TH1.cxx:3564
TH1.cxx:3565
TH1.cxx:3566
TH1.cxx:3567
TH1.cxx:3568
TH1.cxx:3569
TH1.cxx:3570
TH1.cxx:3571
TH1.cxx:3572
TH1.cxx:3573
TH1.cxx:3574
TH1.cxx:3575
TH1.cxx:3576
TH1.cxx:3577
TH1.cxx:3578
TH1.cxx:3579
TH1.cxx:3580
TH1.cxx:3581
TH1.cxx:3582
TH1.cxx:3583
TH1.cxx:3584
TH1.cxx:3585
TH1.cxx:3586
TH1.cxx:3587
TH1.cxx:3588
TH1.cxx:3589
TH1.cxx:3590
TH1.cxx:3591
TH1.cxx:3592
TH1.cxx:3593
TH1.cxx:3594
TH1.cxx:3595
TH1.cxx:3596
TH1.cxx:3597
TH1.cxx:3598
TH1.cxx:3599
TH1.cxx:3600
TH1.cxx:3601
TH1.cxx:3602
TH1.cxx:3603
TH1.cxx:3604
TH1.cxx:3605
TH1.cxx:3606
TH1.cxx:3607
TH1.cxx:3608
TH1.cxx:3609
TH1.cxx:3610
TH1.cxx:3611
TH1.cxx:3612
TH1.cxx:3613
TH1.cxx:3614
TH1.cxx:3615
TH1.cxx:3616
TH1.cxx:3617
TH1.cxx:3618
TH1.cxx:3619
TH1.cxx:3620
TH1.cxx:3621
TH1.cxx:3622
TH1.cxx:3623
TH1.cxx:3624
TH1.cxx:3625
TH1.cxx:3626
TH1.cxx:3627
TH1.cxx:3628
TH1.cxx:3629
TH1.cxx:3630
TH1.cxx:3631
TH1.cxx:3632
TH1.cxx:3633
TH1.cxx:3634
TH1.cxx:3635
TH1.cxx:3636
TH1.cxx:3637
TH1.cxx:3638
TH1.cxx:3639
TH1.cxx:3640
TH1.cxx:3641
TH1.cxx:3642
TH1.cxx:3643
TH1.cxx:3644
TH1.cxx:3645
TH1.cxx:3646
TH1.cxx:3647
TH1.cxx:3648
TH1.cxx:3649
TH1.cxx:3650
TH1.cxx:3651
TH1.cxx:3652
TH1.cxx:3653
TH1.cxx:3654
TH1.cxx:3655
TH1.cxx:3656
TH1.cxx:3657
TH1.cxx:3658
TH1.cxx:3659
TH1.cxx:3660
TH1.cxx:3661
TH1.cxx:3662
TH1.cxx:3663
TH1.cxx:3664
TH1.cxx:3665
TH1.cxx:3666
TH1.cxx:3667
TH1.cxx:3668
TH1.cxx:3669
TH1.cxx:3670
TH1.cxx:3671
TH1.cxx:3672
TH1.cxx:3673
TH1.cxx:3674
TH1.cxx:3675
TH1.cxx:3676
TH1.cxx:3677
TH1.cxx:3678
TH1.cxx:3679
TH1.cxx:3680
TH1.cxx:3681
TH1.cxx:3682
TH1.cxx:3683
TH1.cxx:3684
TH1.cxx:3685
TH1.cxx:3686
TH1.cxx:3687
TH1.cxx:3688
TH1.cxx:3689
TH1.cxx:3690
TH1.cxx:3691
TH1.cxx:3692
TH1.cxx:3693
TH1.cxx:3694
TH1.cxx:3695
TH1.cxx:3696
TH1.cxx:3697
TH1.cxx:3698
TH1.cxx:3699
TH1.cxx:3700
TH1.cxx:3701
TH1.cxx:3702
TH1.cxx:3703
TH1.cxx:3704
TH1.cxx:3705
TH1.cxx:3706
TH1.cxx:3707
TH1.cxx:3708
TH1.cxx:3709
TH1.cxx:3710
TH1.cxx:3711
TH1.cxx:3712
TH1.cxx:3713
TH1.cxx:3714
TH1.cxx:3715
TH1.cxx:3716
TH1.cxx:3717
TH1.cxx:3718
TH1.cxx:3719
TH1.cxx:3720
TH1.cxx:3721
TH1.cxx:3722
TH1.cxx:3723
TH1.cxx:3724
TH1.cxx:3725
TH1.cxx:3726
TH1.cxx:3727
TH1.cxx:3728
TH1.cxx:3729
TH1.cxx:3730
TH1.cxx:3731
TH1.cxx:3732
TH1.cxx:3733
TH1.cxx:3734
TH1.cxx:3735
TH1.cxx:3736
TH1.cxx:3737
TH1.cxx:3738
TH1.cxx:3739
TH1.cxx:3740
TH1.cxx:3741
TH1.cxx:3742
TH1.cxx:3743
TH1.cxx:3744
TH1.cxx:3745
TH1.cxx:3746
TH1.cxx:3747
TH1.cxx:3748
TH1.cxx:3749
TH1.cxx:3750
TH1.cxx:3751
TH1.cxx:3752
TH1.cxx:3753
TH1.cxx:3754
TH1.cxx:3755
TH1.cxx:3756
TH1.cxx:3757
TH1.cxx:3758
TH1.cxx:3759
TH1.cxx:3760
TH1.cxx:3761
TH1.cxx:3762
TH1.cxx:3763
TH1.cxx:3764
TH1.cxx:3765
TH1.cxx:3766
TH1.cxx:3767
TH1.cxx:3768
TH1.cxx:3769
TH1.cxx:3770
TH1.cxx:3771
TH1.cxx:3772
TH1.cxx:3773
TH1.cxx:3774
TH1.cxx:3775
TH1.cxx:3776
TH1.cxx:3777
TH1.cxx:3778
TH1.cxx:3779
TH1.cxx:3780
TH1.cxx:3781
TH1.cxx:3782
TH1.cxx:3783
TH1.cxx:3784
TH1.cxx:3785
TH1.cxx:3786
TH1.cxx:3787
TH1.cxx:3788
TH1.cxx:3789
TH1.cxx:3790
TH1.cxx:3791
TH1.cxx:3792
TH1.cxx:3793
TH1.cxx:3794
TH1.cxx:3795
TH1.cxx:3796
TH1.cxx:3797
TH1.cxx:3798
TH1.cxx:3799
TH1.cxx:3800
TH1.cxx:3801
TH1.cxx:3802
TH1.cxx:3803
TH1.cxx:3804
TH1.cxx:3805
TH1.cxx:3806
TH1.cxx:3807
TH1.cxx:3808
TH1.cxx:3809
TH1.cxx:3810
TH1.cxx:3811
TH1.cxx:3812
TH1.cxx:3813
TH1.cxx:3814
TH1.cxx:3815
TH1.cxx:3816
TH1.cxx:3817
TH1.cxx:3818
TH1.cxx:3819
TH1.cxx:3820
TH1.cxx:3821
TH1.cxx:3822
TH1.cxx:3823
TH1.cxx:3824
TH1.cxx:3825
TH1.cxx:3826
TH1.cxx:3827
TH1.cxx:3828
TH1.cxx:3829
TH1.cxx:3830
TH1.cxx:3831
TH1.cxx:3832
TH1.cxx:3833
TH1.cxx:3834
TH1.cxx:3835
TH1.cxx:3836
TH1.cxx:3837
TH1.cxx:3838
TH1.cxx:3839
TH1.cxx:3840
TH1.cxx:3841
TH1.cxx:3842
TH1.cxx:3843
TH1.cxx:3844
TH1.cxx:3845
TH1.cxx:3846
TH1.cxx:3847
TH1.cxx:3848
TH1.cxx:3849
TH1.cxx:3850
TH1.cxx:3851
TH1.cxx:3852
TH1.cxx:3853
TH1.cxx:3854
TH1.cxx:3855
TH1.cxx:3856
TH1.cxx:3857
TH1.cxx:3858
TH1.cxx:3859
TH1.cxx:3860
TH1.cxx:3861
TH1.cxx:3862
TH1.cxx:3863
TH1.cxx:3864
TH1.cxx:3865
TH1.cxx:3866
TH1.cxx:3867
TH1.cxx:3868
TH1.cxx:3869
TH1.cxx:3870
TH1.cxx:3871
TH1.cxx:3872
TH1.cxx:3873
TH1.cxx:3874
TH1.cxx:3875
TH1.cxx:3876
TH1.cxx:3877
TH1.cxx:3878
TH1.cxx:3879
TH1.cxx:3880
TH1.cxx:3881
TH1.cxx:3882
TH1.cxx:3883
TH1.cxx:3884
TH1.cxx:3885
TH1.cxx:3886
TH1.cxx:3887
TH1.cxx:3888
TH1.cxx:3889
TH1.cxx:3890
TH1.cxx:3891
TH1.cxx:3892
TH1.cxx:3893
TH1.cxx:3894
TH1.cxx:3895
TH1.cxx:3896
TH1.cxx:3897
TH1.cxx:3898
TH1.cxx:3899
TH1.cxx:3900
TH1.cxx:3901
TH1.cxx:3902
TH1.cxx:3903
TH1.cxx:3904
TH1.cxx:3905
TH1.cxx:3906
TH1.cxx:3907
TH1.cxx:3908
TH1.cxx:3909
TH1.cxx:3910
TH1.cxx:3911
TH1.cxx:3912
TH1.cxx:3913
TH1.cxx:3914
TH1.cxx:3915
TH1.cxx:3916
TH1.cxx:3917
TH1.cxx:3918
TH1.cxx:3919
TH1.cxx:3920
TH1.cxx:3921
TH1.cxx:3922
TH1.cxx:3923
TH1.cxx:3924
TH1.cxx:3925
TH1.cxx:3926
TH1.cxx:3927
TH1.cxx:3928
TH1.cxx:3929
TH1.cxx:3930
TH1.cxx:3931
TH1.cxx:3932
TH1.cxx:3933
TH1.cxx:3934
TH1.cxx:3935
TH1.cxx:3936
TH1.cxx:3937
TH1.cxx:3938
TH1.cxx:3939
TH1.cxx:3940
TH1.cxx:3941
TH1.cxx:3942
TH1.cxx:3943
TH1.cxx:3944
TH1.cxx:3945
TH1.cxx:3946
TH1.cxx:3947
TH1.cxx:3948
TH1.cxx:3949
TH1.cxx:3950
TH1.cxx:3951
TH1.cxx:3952
TH1.cxx:3953
TH1.cxx:3954
TH1.cxx:3955
TH1.cxx:3956
TH1.cxx:3957
TH1.cxx:3958
TH1.cxx:3959
TH1.cxx:3960
TH1.cxx:3961
TH1.cxx:3962
TH1.cxx:3963
TH1.cxx:3964
TH1.cxx:3965
TH1.cxx:3966
TH1.cxx:3967
TH1.cxx:3968
TH1.cxx:3969
TH1.cxx:3970
TH1.cxx:3971
TH1.cxx:3972
TH1.cxx:3973
TH1.cxx:3974
TH1.cxx:3975
TH1.cxx:3976
TH1.cxx:3977
TH1.cxx:3978
TH1.cxx:3979
TH1.cxx:3980
TH1.cxx:3981
TH1.cxx:3982
TH1.cxx:3983
TH1.cxx:3984
TH1.cxx:3985
TH1.cxx:3986
TH1.cxx:3987
TH1.cxx:3988
TH1.cxx:3989
TH1.cxx:3990
TH1.cxx:3991
TH1.cxx:3992
TH1.cxx:3993
TH1.cxx:3994
TH1.cxx:3995
TH1.cxx:3996
TH1.cxx:3997
TH1.cxx:3998
TH1.cxx:3999
TH1.cxx:4000
TH1.cxx:4001
TH1.cxx:4002
TH1.cxx:4003
TH1.cxx:4004
TH1.cxx:4005
TH1.cxx:4006
TH1.cxx:4007
TH1.cxx:4008
TH1.cxx:4009
TH1.cxx:4010
TH1.cxx:4011
TH1.cxx:4012
TH1.cxx:4013
TH1.cxx:4014
TH1.cxx:4015
TH1.cxx:4016
TH1.cxx:4017
TH1.cxx:4018
TH1.cxx:4019
TH1.cxx:4020
TH1.cxx:4021
TH1.cxx:4022
TH1.cxx:4023
TH1.cxx:4024
TH1.cxx:4025
TH1.cxx:4026
TH1.cxx:4027
TH1.cxx:4028
TH1.cxx:4029
TH1.cxx:4030
TH1.cxx:4031
TH1.cxx:4032
TH1.cxx:4033
TH1.cxx:4034
TH1.cxx:4035
TH1.cxx:4036
TH1.cxx:4037
TH1.cxx:4038
TH1.cxx:4039
TH1.cxx:4040
TH1.cxx:4041
TH1.cxx:4042
TH1.cxx:4043
TH1.cxx:4044
TH1.cxx:4045
TH1.cxx:4046
TH1.cxx:4047
TH1.cxx:4048
TH1.cxx:4049
TH1.cxx:4050
TH1.cxx:4051
TH1.cxx:4052
TH1.cxx:4053
TH1.cxx:4054
TH1.cxx:4055
TH1.cxx:4056
TH1.cxx:4057
TH1.cxx:4058
TH1.cxx:4059
TH1.cxx:4060
TH1.cxx:4061
TH1.cxx:4062
TH1.cxx:4063
TH1.cxx:4064
TH1.cxx:4065
TH1.cxx:4066
TH1.cxx:4067
TH1.cxx:4068
TH1.cxx:4069
TH1.cxx:4070
TH1.cxx:4071
TH1.cxx:4072
TH1.cxx:4073
TH1.cxx:4074
TH1.cxx:4075
TH1.cxx:4076
TH1.cxx:4077
TH1.cxx:4078
TH1.cxx:4079
TH1.cxx:4080
TH1.cxx:4081
TH1.cxx:4082
TH1.cxx:4083
TH1.cxx:4084
TH1.cxx:4085
TH1.cxx:4086
TH1.cxx:4087
TH1.cxx:4088
TH1.cxx:4089
TH1.cxx:4090
TH1.cxx:4091
TH1.cxx:4092
TH1.cxx:4093
TH1.cxx:4094
TH1.cxx:4095
TH1.cxx:4096
TH1.cxx:4097
TH1.cxx:4098
TH1.cxx:4099
TH1.cxx:4100
TH1.cxx:4101
TH1.cxx:4102
TH1.cxx:4103
TH1.cxx:4104
TH1.cxx:4105
TH1.cxx:4106
TH1.cxx:4107
TH1.cxx:4108
TH1.cxx:4109
TH1.cxx:4110
TH1.cxx:4111
TH1.cxx:4112
TH1.cxx:4113
TH1.cxx:4114
TH1.cxx:4115
TH1.cxx:4116
TH1.cxx:4117
TH1.cxx:4118
TH1.cxx:4119
TH1.cxx:4120
TH1.cxx:4121
TH1.cxx:4122
TH1.cxx:4123
TH1.cxx:4124
TH1.cxx:4125
TH1.cxx:4126
TH1.cxx:4127
TH1.cxx:4128
TH1.cxx:4129
TH1.cxx:4130
TH1.cxx:4131
TH1.cxx:4132
TH1.cxx:4133
TH1.cxx:4134
TH1.cxx:4135
TH1.cxx:4136
TH1.cxx:4137
TH1.cxx:4138
TH1.cxx:4139
TH1.cxx:4140
TH1.cxx:4141
TH1.cxx:4142
TH1.cxx:4143
TH1.cxx:4144
TH1.cxx:4145
TH1.cxx:4146
TH1.cxx:4147
TH1.cxx:4148
TH1.cxx:4149
TH1.cxx:4150
TH1.cxx:4151
TH1.cxx:4152
TH1.cxx:4153
TH1.cxx:4154
TH1.cxx:4155
TH1.cxx:4156
TH1.cxx:4157
TH1.cxx:4158
TH1.cxx:4159
TH1.cxx:4160
TH1.cxx:4161
TH1.cxx:4162
TH1.cxx:4163
TH1.cxx:4164
TH1.cxx:4165
TH1.cxx:4166
TH1.cxx:4167
TH1.cxx:4168
TH1.cxx:4169
TH1.cxx:4170
TH1.cxx:4171
TH1.cxx:4172
TH1.cxx:4173
TH1.cxx:4174
TH1.cxx:4175
TH1.cxx:4176
TH1.cxx:4177
TH1.cxx:4178
TH1.cxx:4179
TH1.cxx:4180
TH1.cxx:4181
TH1.cxx:4182
TH1.cxx:4183
TH1.cxx:4184
TH1.cxx:4185
TH1.cxx:4186
TH1.cxx:4187
TH1.cxx:4188
TH1.cxx:4189
TH1.cxx:4190
TH1.cxx:4191
TH1.cxx:4192
TH1.cxx:4193
TH1.cxx:4194
TH1.cxx:4195
TH1.cxx:4196
TH1.cxx:4197
TH1.cxx:4198
TH1.cxx:4199
TH1.cxx:4200
TH1.cxx:4201
TH1.cxx:4202
TH1.cxx:4203
TH1.cxx:4204
TH1.cxx:4205
TH1.cxx:4206
TH1.cxx:4207
TH1.cxx:4208
TH1.cxx:4209
TH1.cxx:4210
TH1.cxx:4211
TH1.cxx:4212
TH1.cxx:4213
TH1.cxx:4214
TH1.cxx:4215
TH1.cxx:4216
TH1.cxx:4217
TH1.cxx:4218
TH1.cxx:4219
TH1.cxx:4220
TH1.cxx:4221
TH1.cxx:4222
TH1.cxx:4223
TH1.cxx:4224
TH1.cxx:4225
TH1.cxx:4226
TH1.cxx:4227
TH1.cxx:4228
TH1.cxx:4229
TH1.cxx:4230
TH1.cxx:4231
TH1.cxx:4232
TH1.cxx:4233
TH1.cxx:4234
TH1.cxx:4235
TH1.cxx:4236
TH1.cxx:4237
TH1.cxx:4238
TH1.cxx:4239
TH1.cxx:4240
TH1.cxx:4241
TH1.cxx:4242
TH1.cxx:4243
TH1.cxx:4244
TH1.cxx:4245
TH1.cxx:4246
TH1.cxx:4247
TH1.cxx:4248
TH1.cxx:4249
TH1.cxx:4250
TH1.cxx:4251
TH1.cxx:4252
TH1.cxx:4253
TH1.cxx:4254
TH1.cxx:4255
TH1.cxx:4256
TH1.cxx:4257
TH1.cxx:4258
TH1.cxx:4259
TH1.cxx:4260
TH1.cxx:4261
TH1.cxx:4262
TH1.cxx:4263
TH1.cxx:4264
TH1.cxx:4265
TH1.cxx:4266
TH1.cxx:4267
TH1.cxx:4268
TH1.cxx:4269
TH1.cxx:4270
TH1.cxx:4271
TH1.cxx:4272
TH1.cxx:4273
TH1.cxx:4274
TH1.cxx:4275
TH1.cxx:4276
TH1.cxx:4277
TH1.cxx:4278
TH1.cxx:4279
TH1.cxx:4280
TH1.cxx:4281
TH1.cxx:4282
TH1.cxx:4283
TH1.cxx:4284
TH1.cxx:4285
TH1.cxx:4286
TH1.cxx:4287
TH1.cxx:4288
TH1.cxx:4289
TH1.cxx:4290
TH1.cxx:4291
TH1.cxx:4292
TH1.cxx:4293
TH1.cxx:4294
TH1.cxx:4295
TH1.cxx:4296
TH1.cxx:4297
TH1.cxx:4298
TH1.cxx:4299
TH1.cxx:4300
TH1.cxx:4301
TH1.cxx:4302
TH1.cxx:4303
TH1.cxx:4304
TH1.cxx:4305
TH1.cxx:4306
TH1.cxx:4307
TH1.cxx:4308
TH1.cxx:4309
TH1.cxx:4310
TH1.cxx:4311
TH1.cxx:4312
TH1.cxx:4313
TH1.cxx:4314
TH1.cxx:4315
TH1.cxx:4316
TH1.cxx:4317
TH1.cxx:4318
TH1.cxx:4319
TH1.cxx:4320
TH1.cxx:4321
TH1.cxx:4322
TH1.cxx:4323
TH1.cxx:4324
TH1.cxx:4325
TH1.cxx:4326
TH1.cxx:4327
TH1.cxx:4328
TH1.cxx:4329
TH1.cxx:4330
TH1.cxx:4331
TH1.cxx:4332
TH1.cxx:4333
TH1.cxx:4334
TH1.cxx:4335
TH1.cxx:4336
TH1.cxx:4337
TH1.cxx:4338
TH1.cxx:4339
TH1.cxx:4340
TH1.cxx:4341
TH1.cxx:4342
TH1.cxx:4343
TH1.cxx:4344
TH1.cxx:4345
TH1.cxx:4346
TH1.cxx:4347
TH1.cxx:4348
TH1.cxx:4349
TH1.cxx:4350
TH1.cxx:4351
TH1.cxx:4352
TH1.cxx:4353
TH1.cxx:4354
TH1.cxx:4355
TH1.cxx:4356
TH1.cxx:4357
TH1.cxx:4358
TH1.cxx:4359
TH1.cxx:4360
TH1.cxx:4361
TH1.cxx:4362
TH1.cxx:4363
TH1.cxx:4364
TH1.cxx:4365
TH1.cxx:4366
TH1.cxx:4367
TH1.cxx:4368
TH1.cxx:4369
TH1.cxx:4370
TH1.cxx:4371
TH1.cxx:4372
TH1.cxx:4373
TH1.cxx:4374
TH1.cxx:4375
TH1.cxx:4376
TH1.cxx:4377
TH1.cxx:4378
TH1.cxx:4379
TH1.cxx:4380
TH1.cxx:4381
TH1.cxx:4382
TH1.cxx:4383
TH1.cxx:4384
TH1.cxx:4385
TH1.cxx:4386
TH1.cxx:4387
TH1.cxx:4388
TH1.cxx:4389
TH1.cxx:4390
TH1.cxx:4391
TH1.cxx:4392
TH1.cxx:4393
TH1.cxx:4394
TH1.cxx:4395
TH1.cxx:4396
TH1.cxx:4397
TH1.cxx:4398
TH1.cxx:4399
TH1.cxx:4400
TH1.cxx:4401
TH1.cxx:4402
TH1.cxx:4403
TH1.cxx:4404
TH1.cxx:4405
TH1.cxx:4406
TH1.cxx:4407
TH1.cxx:4408
TH1.cxx:4409
TH1.cxx:4410
TH1.cxx:4411
TH1.cxx:4412
TH1.cxx:4413
TH1.cxx:4414
TH1.cxx:4415
TH1.cxx:4416
TH1.cxx:4417
TH1.cxx:4418
TH1.cxx:4419
TH1.cxx:4420
TH1.cxx:4421
TH1.cxx:4422
TH1.cxx:4423
TH1.cxx:4424
TH1.cxx:4425
TH1.cxx:4426
TH1.cxx:4427
TH1.cxx:4428
TH1.cxx:4429
TH1.cxx:4430
TH1.cxx:4431
TH1.cxx:4432
TH1.cxx:4433
TH1.cxx:4434
TH1.cxx:4435
TH1.cxx:4436
TH1.cxx:4437
TH1.cxx:4438
TH1.cxx:4439
TH1.cxx:4440
TH1.cxx:4441
TH1.cxx:4442
TH1.cxx:4443
TH1.cxx:4444
TH1.cxx:4445
TH1.cxx:4446
TH1.cxx:4447
TH1.cxx:4448
TH1.cxx:4449
TH1.cxx:4450
TH1.cxx:4451
TH1.cxx:4452
TH1.cxx:4453
TH1.cxx:4454
TH1.cxx:4455
TH1.cxx:4456
TH1.cxx:4457
TH1.cxx:4458
TH1.cxx:4459
TH1.cxx:4460
TH1.cxx:4461
TH1.cxx:4462
TH1.cxx:4463
TH1.cxx:4464
TH1.cxx:4465
TH1.cxx:4466
TH1.cxx:4467
TH1.cxx:4468
TH1.cxx:4469
TH1.cxx:4470
TH1.cxx:4471
TH1.cxx:4472
TH1.cxx:4473
TH1.cxx:4474
TH1.cxx:4475
TH1.cxx:4476
TH1.cxx:4477
TH1.cxx:4478
TH1.cxx:4479
TH1.cxx:4480
TH1.cxx:4481
TH1.cxx:4482
TH1.cxx:4483
TH1.cxx:4484
TH1.cxx:4485
TH1.cxx:4486
TH1.cxx:4487
TH1.cxx:4488
TH1.cxx:4489
TH1.cxx:4490
TH1.cxx:4491
TH1.cxx:4492
TH1.cxx:4493
TH1.cxx:4494
TH1.cxx:4495
TH1.cxx:4496
TH1.cxx:4497
TH1.cxx:4498
TH1.cxx:4499
TH1.cxx:4500
TH1.cxx:4501
TH1.cxx:4502
TH1.cxx:4503
TH1.cxx:4504
TH1.cxx:4505
TH1.cxx:4506
TH1.cxx:4507
TH1.cxx:4508
TH1.cxx:4509
TH1.cxx:4510
TH1.cxx:4511
TH1.cxx:4512
TH1.cxx:4513
TH1.cxx:4514
TH1.cxx:4515
TH1.cxx:4516
TH1.cxx:4517
TH1.cxx:4518
TH1.cxx:4519
TH1.cxx:4520
TH1.cxx:4521
TH1.cxx:4522
TH1.cxx:4523
TH1.cxx:4524
TH1.cxx:4525
TH1.cxx:4526
TH1.cxx:4527
TH1.cxx:4528
TH1.cxx:4529
TH1.cxx:4530
TH1.cxx:4531
TH1.cxx:4532
TH1.cxx:4533
TH1.cxx:4534
TH1.cxx:4535
TH1.cxx:4536
TH1.cxx:4537
TH1.cxx:4538
TH1.cxx:4539
TH1.cxx:4540
TH1.cxx:4541
TH1.cxx:4542
TH1.cxx:4543
TH1.cxx:4544
TH1.cxx:4545
TH1.cxx:4546
TH1.cxx:4547
TH1.cxx:4548
TH1.cxx:4549
TH1.cxx:4550
TH1.cxx:4551
TH1.cxx:4552
TH1.cxx:4553
TH1.cxx:4554
TH1.cxx:4555
TH1.cxx:4556
TH1.cxx:4557
TH1.cxx:4558
TH1.cxx:4559
TH1.cxx:4560
TH1.cxx:4561
TH1.cxx:4562
TH1.cxx:4563
TH1.cxx:4564
TH1.cxx:4565
TH1.cxx:4566
TH1.cxx:4567
TH1.cxx:4568
TH1.cxx:4569
TH1.cxx:4570
TH1.cxx:4571
TH1.cxx:4572
TH1.cxx:4573
TH1.cxx:4574
TH1.cxx:4575
TH1.cxx:4576
TH1.cxx:4577
TH1.cxx:4578
TH1.cxx:4579
TH1.cxx:4580
TH1.cxx:4581
TH1.cxx:4582
TH1.cxx:4583
TH1.cxx:4584
TH1.cxx:4585
TH1.cxx:4586
TH1.cxx:4587
TH1.cxx:4588
TH1.cxx:4589
TH1.cxx:4590
TH1.cxx:4591
TH1.cxx:4592
TH1.cxx:4593
TH1.cxx:4594
TH1.cxx:4595
TH1.cxx:4596
TH1.cxx:4597
TH1.cxx:4598
TH1.cxx:4599
TH1.cxx:4600
TH1.cxx:4601
TH1.cxx:4602
TH1.cxx:4603
TH1.cxx:4604
TH1.cxx:4605
TH1.cxx:4606
TH1.cxx:4607
TH1.cxx:4608
TH1.cxx:4609
TH1.cxx:4610
TH1.cxx:4611
TH1.cxx:4612
TH1.cxx:4613
TH1.cxx:4614
TH1.cxx:4615
TH1.cxx:4616
TH1.cxx:4617
TH1.cxx:4618
TH1.cxx:4619
TH1.cxx:4620
TH1.cxx:4621
TH1.cxx:4622
TH1.cxx:4623
TH1.cxx:4624
TH1.cxx:4625
TH1.cxx:4626
TH1.cxx:4627
TH1.cxx:4628
TH1.cxx:4629
TH1.cxx:4630
TH1.cxx:4631
TH1.cxx:4632
TH1.cxx:4633
TH1.cxx:4634
TH1.cxx:4635
TH1.cxx:4636
TH1.cxx:4637
TH1.cxx:4638
TH1.cxx:4639
TH1.cxx:4640
TH1.cxx:4641
TH1.cxx:4642
TH1.cxx:4643
TH1.cxx:4644
TH1.cxx:4645
TH1.cxx:4646
TH1.cxx:4647
TH1.cxx:4648
TH1.cxx:4649
TH1.cxx:4650
TH1.cxx:4651
TH1.cxx:4652
TH1.cxx:4653
TH1.cxx:4654
TH1.cxx:4655
TH1.cxx:4656
TH1.cxx:4657
TH1.cxx:4658
TH1.cxx:4659
TH1.cxx:4660
TH1.cxx:4661
TH1.cxx:4662
TH1.cxx:4663
TH1.cxx:4664
TH1.cxx:4665
TH1.cxx:4666
TH1.cxx:4667
TH1.cxx:4668
TH1.cxx:4669
TH1.cxx:4670
TH1.cxx:4671
TH1.cxx:4672
TH1.cxx:4673
TH1.cxx:4674
TH1.cxx:4675
TH1.cxx:4676
TH1.cxx:4677
TH1.cxx:4678
TH1.cxx:4679
TH1.cxx:4680
TH1.cxx:4681
TH1.cxx:4682
TH1.cxx:4683
TH1.cxx:4684
TH1.cxx:4685
TH1.cxx:4686
TH1.cxx:4687
TH1.cxx:4688
TH1.cxx:4689
TH1.cxx:4690
TH1.cxx:4691
TH1.cxx:4692
TH1.cxx:4693
TH1.cxx:4694
TH1.cxx:4695
TH1.cxx:4696
TH1.cxx:4697
TH1.cxx:4698
TH1.cxx:4699
TH1.cxx:4700
TH1.cxx:4701
TH1.cxx:4702
TH1.cxx:4703
TH1.cxx:4704
TH1.cxx:4705
TH1.cxx:4706
TH1.cxx:4707
TH1.cxx:4708
TH1.cxx:4709
TH1.cxx:4710
TH1.cxx:4711
TH1.cxx:4712
TH1.cxx:4713
TH1.cxx:4714
TH1.cxx:4715
TH1.cxx:4716
TH1.cxx:4717
TH1.cxx:4718
TH1.cxx:4719
TH1.cxx:4720
TH1.cxx:4721
TH1.cxx:4722
TH1.cxx:4723
TH1.cxx:4724
TH1.cxx:4725
TH1.cxx:4726
TH1.cxx:4727
TH1.cxx:4728
TH1.cxx:4729
TH1.cxx:4730
TH1.cxx:4731
TH1.cxx:4732
TH1.cxx:4733
TH1.cxx:4734
TH1.cxx:4735
TH1.cxx:4736
TH1.cxx:4737
TH1.cxx:4738
TH1.cxx:4739
TH1.cxx:4740
TH1.cxx:4741
TH1.cxx:4742
TH1.cxx:4743
TH1.cxx:4744
TH1.cxx:4745
TH1.cxx:4746
TH1.cxx:4747
TH1.cxx:4748
TH1.cxx:4749
TH1.cxx:4750
TH1.cxx:4751
TH1.cxx:4752
TH1.cxx:4753
TH1.cxx:4754
TH1.cxx:4755
TH1.cxx:4756
TH1.cxx:4757
TH1.cxx:4758
TH1.cxx:4759
TH1.cxx:4760
TH1.cxx:4761
TH1.cxx:4762
TH1.cxx:4763
TH1.cxx:4764
TH1.cxx:4765
TH1.cxx:4766
TH1.cxx:4767
TH1.cxx:4768
TH1.cxx:4769
TH1.cxx:4770
TH1.cxx:4771
TH1.cxx:4772
TH1.cxx:4773
TH1.cxx:4774
TH1.cxx:4775
TH1.cxx:4776
TH1.cxx:4777
TH1.cxx:4778
TH1.cxx:4779
TH1.cxx:4780
TH1.cxx:4781
TH1.cxx:4782
TH1.cxx:4783
TH1.cxx:4784
TH1.cxx:4785
TH1.cxx:4786
TH1.cxx:4787
TH1.cxx:4788
TH1.cxx:4789
TH1.cxx:4790
TH1.cxx:4791
TH1.cxx:4792
TH1.cxx:4793
TH1.cxx:4794
TH1.cxx:4795
TH1.cxx:4796
TH1.cxx:4797
TH1.cxx:4798
TH1.cxx:4799
TH1.cxx:4800
TH1.cxx:4801
TH1.cxx:4802
TH1.cxx:4803
TH1.cxx:4804
TH1.cxx:4805
TH1.cxx:4806
TH1.cxx:4807
TH1.cxx:4808
TH1.cxx:4809
TH1.cxx:4810
TH1.cxx:4811
TH1.cxx:4812
TH1.cxx:4813
TH1.cxx:4814
TH1.cxx:4815
TH1.cxx:4816
TH1.cxx:4817
TH1.cxx:4818
TH1.cxx:4819
TH1.cxx:4820
TH1.cxx:4821
TH1.cxx:4822
TH1.cxx:4823
TH1.cxx:4824
TH1.cxx:4825
TH1.cxx:4826
TH1.cxx:4827
TH1.cxx:4828
TH1.cxx:4829
TH1.cxx:4830
TH1.cxx:4831
TH1.cxx:4832
TH1.cxx:4833
TH1.cxx:4834
TH1.cxx:4835
TH1.cxx:4836
TH1.cxx:4837
TH1.cxx:4838
TH1.cxx:4839
TH1.cxx:4840
TH1.cxx:4841
TH1.cxx:4842
TH1.cxx:4843
TH1.cxx:4844
TH1.cxx:4845
TH1.cxx:4846
TH1.cxx:4847
TH1.cxx:4848
TH1.cxx:4849
TH1.cxx:4850
TH1.cxx:4851
TH1.cxx:4852
TH1.cxx:4853
TH1.cxx:4854
TH1.cxx:4855
TH1.cxx:4856
TH1.cxx:4857
TH1.cxx:4858
TH1.cxx:4859
TH1.cxx:4860
TH1.cxx:4861
TH1.cxx:4862
TH1.cxx:4863
TH1.cxx:4864
TH1.cxx:4865
TH1.cxx:4866
TH1.cxx:4867
TH1.cxx:4868
TH1.cxx:4869
TH1.cxx:4870
TH1.cxx:4871
TH1.cxx:4872
TH1.cxx:4873
TH1.cxx:4874
TH1.cxx:4875
TH1.cxx:4876
TH1.cxx:4877
TH1.cxx:4878
TH1.cxx:4879
TH1.cxx:4880
TH1.cxx:4881
TH1.cxx:4882
TH1.cxx:4883
TH1.cxx:4884
TH1.cxx:4885
TH1.cxx:4886
TH1.cxx:4887
TH1.cxx:4888
TH1.cxx:4889
TH1.cxx:4890
TH1.cxx:4891
TH1.cxx:4892
TH1.cxx:4893
TH1.cxx:4894
TH1.cxx:4895
TH1.cxx:4896
TH1.cxx:4897
TH1.cxx:4898
TH1.cxx:4899
TH1.cxx:4900
TH1.cxx:4901
TH1.cxx:4902
TH1.cxx:4903
TH1.cxx:4904
TH1.cxx:4905
TH1.cxx:4906
TH1.cxx:4907
TH1.cxx:4908
TH1.cxx:4909
TH1.cxx:4910
TH1.cxx:4911
TH1.cxx:4912
TH1.cxx:4913
TH1.cxx:4914
TH1.cxx:4915
TH1.cxx:4916
TH1.cxx:4917
TH1.cxx:4918
TH1.cxx:4919
TH1.cxx:4920
TH1.cxx:4921
TH1.cxx:4922
TH1.cxx:4923
TH1.cxx:4924
TH1.cxx:4925
TH1.cxx:4926
TH1.cxx:4927
TH1.cxx:4928
TH1.cxx:4929
TH1.cxx:4930
TH1.cxx:4931
TH1.cxx:4932
TH1.cxx:4933
TH1.cxx:4934
TH1.cxx:4935
TH1.cxx:4936
TH1.cxx:4937
TH1.cxx:4938
TH1.cxx:4939
TH1.cxx:4940
TH1.cxx:4941
TH1.cxx:4942
TH1.cxx:4943
TH1.cxx:4944
TH1.cxx:4945
TH1.cxx:4946
TH1.cxx:4947
TH1.cxx:4948
TH1.cxx:4949
TH1.cxx:4950
TH1.cxx:4951
TH1.cxx:4952
TH1.cxx:4953
TH1.cxx:4954
TH1.cxx:4955
TH1.cxx:4956
TH1.cxx:4957
TH1.cxx:4958
TH1.cxx:4959
TH1.cxx:4960
TH1.cxx:4961
TH1.cxx:4962
TH1.cxx:4963
TH1.cxx:4964
TH1.cxx:4965
TH1.cxx:4966
TH1.cxx:4967
TH1.cxx:4968
TH1.cxx:4969
TH1.cxx:4970
TH1.cxx:4971
TH1.cxx:4972
TH1.cxx:4973
TH1.cxx:4974
TH1.cxx:4975
TH1.cxx:4976
TH1.cxx:4977
TH1.cxx:4978
TH1.cxx:4979
TH1.cxx:4980
TH1.cxx:4981
TH1.cxx:4982
TH1.cxx:4983
TH1.cxx:4984
TH1.cxx:4985
TH1.cxx:4986
TH1.cxx:4987
TH1.cxx:4988
TH1.cxx:4989
TH1.cxx:4990
TH1.cxx:4991
TH1.cxx:4992
TH1.cxx:4993
TH1.cxx:4994
TH1.cxx:4995
TH1.cxx:4996
TH1.cxx:4997
TH1.cxx:4998
TH1.cxx:4999
TH1.cxx:5000
TH1.cxx:5001
TH1.cxx:5002
TH1.cxx:5003
TH1.cxx:5004
TH1.cxx:5005
TH1.cxx:5006
TH1.cxx:5007
TH1.cxx:5008
TH1.cxx:5009
TH1.cxx:5010
TH1.cxx:5011
TH1.cxx:5012
TH1.cxx:5013
TH1.cxx:5014
TH1.cxx:5015
TH1.cxx:5016
TH1.cxx:5017
TH1.cxx:5018
TH1.cxx:5019
TH1.cxx:5020
TH1.cxx:5021
TH1.cxx:5022
TH1.cxx:5023
TH1.cxx:5024
TH1.cxx:5025
TH1.cxx:5026
TH1.cxx:5027
TH1.cxx:5028
TH1.cxx:5029
TH1.cxx:5030
TH1.cxx:5031
TH1.cxx:5032
TH1.cxx:5033
TH1.cxx:5034
TH1.cxx:5035
TH1.cxx:5036
TH1.cxx:5037
TH1.cxx:5038
TH1.cxx:5039
TH1.cxx:5040
TH1.cxx:5041
TH1.cxx:5042
TH1.cxx:5043
TH1.cxx:5044
TH1.cxx:5045
TH1.cxx:5046
TH1.cxx:5047
TH1.cxx:5048
TH1.cxx:5049
TH1.cxx:5050
TH1.cxx:5051
TH1.cxx:5052
TH1.cxx:5053
TH1.cxx:5054
TH1.cxx:5055
TH1.cxx:5056
TH1.cxx:5057
TH1.cxx:5058
TH1.cxx:5059
TH1.cxx:5060
TH1.cxx:5061
TH1.cxx:5062
TH1.cxx:5063
TH1.cxx:5064
TH1.cxx:5065
TH1.cxx:5066
TH1.cxx:5067
TH1.cxx:5068
TH1.cxx:5069
TH1.cxx:5070
TH1.cxx:5071
TH1.cxx:5072
TH1.cxx:5073
TH1.cxx:5074
TH1.cxx:5075
TH1.cxx:5076
TH1.cxx:5077
TH1.cxx:5078
TH1.cxx:5079
TH1.cxx:5080
TH1.cxx:5081
TH1.cxx:5082
TH1.cxx:5083
TH1.cxx:5084
TH1.cxx:5085
TH1.cxx:5086
TH1.cxx:5087
TH1.cxx:5088
TH1.cxx:5089
TH1.cxx:5090
TH1.cxx:5091
TH1.cxx:5092
TH1.cxx:5093
TH1.cxx:5094
TH1.cxx:5095
TH1.cxx:5096
TH1.cxx:5097
TH1.cxx:5098
TH1.cxx:5099
TH1.cxx:5100
TH1.cxx:5101
TH1.cxx:5102
TH1.cxx:5103
TH1.cxx:5104
TH1.cxx:5105
TH1.cxx:5106
TH1.cxx:5107
TH1.cxx:5108
TH1.cxx:5109
TH1.cxx:5110
TH1.cxx:5111
TH1.cxx:5112
TH1.cxx:5113
TH1.cxx:5114
TH1.cxx:5115
TH1.cxx:5116
TH1.cxx:5117
TH1.cxx:5118
TH1.cxx:5119
TH1.cxx:5120
TH1.cxx:5121
TH1.cxx:5122
TH1.cxx:5123
TH1.cxx:5124
TH1.cxx:5125
TH1.cxx:5126
TH1.cxx:5127
TH1.cxx:5128
TH1.cxx:5129
TH1.cxx:5130
TH1.cxx:5131
TH1.cxx:5132
TH1.cxx:5133
TH1.cxx:5134
TH1.cxx:5135
TH1.cxx:5136
TH1.cxx:5137
TH1.cxx:5138
TH1.cxx:5139
TH1.cxx:5140
TH1.cxx:5141
TH1.cxx:5142
TH1.cxx:5143
TH1.cxx:5144
TH1.cxx:5145
TH1.cxx:5146
TH1.cxx:5147
TH1.cxx:5148
TH1.cxx:5149
TH1.cxx:5150
TH1.cxx:5151
TH1.cxx:5152
TH1.cxx:5153
TH1.cxx:5154
TH1.cxx:5155
TH1.cxx:5156
TH1.cxx:5157
TH1.cxx:5158
TH1.cxx:5159
TH1.cxx:5160
TH1.cxx:5161
TH1.cxx:5162
TH1.cxx:5163
TH1.cxx:5164
TH1.cxx:5165
TH1.cxx:5166
TH1.cxx:5167
TH1.cxx:5168
TH1.cxx:5169
TH1.cxx:5170
TH1.cxx:5171
TH1.cxx:5172
TH1.cxx:5173
TH1.cxx:5174
TH1.cxx:5175
TH1.cxx:5176
TH1.cxx:5177
TH1.cxx:5178
TH1.cxx:5179
TH1.cxx:5180
TH1.cxx:5181
TH1.cxx:5182
TH1.cxx:5183
TH1.cxx:5184
TH1.cxx:5185
TH1.cxx:5186
TH1.cxx:5187
TH1.cxx:5188
TH1.cxx:5189
TH1.cxx:5190
TH1.cxx:5191
TH1.cxx:5192
TH1.cxx:5193
TH1.cxx:5194
TH1.cxx:5195
TH1.cxx:5196
TH1.cxx:5197
TH1.cxx:5198
TH1.cxx:5199
TH1.cxx:5200
TH1.cxx:5201
TH1.cxx:5202
TH1.cxx:5203
TH1.cxx:5204
TH1.cxx:5205
TH1.cxx:5206
TH1.cxx:5207
TH1.cxx:5208
TH1.cxx:5209
TH1.cxx:5210
TH1.cxx:5211
TH1.cxx:5212
TH1.cxx:5213
TH1.cxx:5214
TH1.cxx:5215
TH1.cxx:5216
TH1.cxx:5217
TH1.cxx:5218
TH1.cxx:5219
TH1.cxx:5220
TH1.cxx:5221
TH1.cxx:5222
TH1.cxx:5223
TH1.cxx:5224
TH1.cxx:5225
TH1.cxx:5226
TH1.cxx:5227
TH1.cxx:5228
TH1.cxx:5229
TH1.cxx:5230
TH1.cxx:5231
TH1.cxx:5232
TH1.cxx:5233
TH1.cxx:5234
TH1.cxx:5235
TH1.cxx:5236
TH1.cxx:5237
TH1.cxx:5238
TH1.cxx:5239
TH1.cxx:5240
TH1.cxx:5241
TH1.cxx:5242
TH1.cxx:5243
TH1.cxx:5244
TH1.cxx:5245
TH1.cxx:5246
TH1.cxx:5247
TH1.cxx:5248
TH1.cxx:5249
TH1.cxx:5250
TH1.cxx:5251
TH1.cxx:5252
TH1.cxx:5253
TH1.cxx:5254
TH1.cxx:5255
TH1.cxx:5256
TH1.cxx:5257
TH1.cxx:5258
TH1.cxx:5259
TH1.cxx:5260
TH1.cxx:5261
TH1.cxx:5262
TH1.cxx:5263
TH1.cxx:5264
TH1.cxx:5265
TH1.cxx:5266
TH1.cxx:5267
TH1.cxx:5268
TH1.cxx:5269
TH1.cxx:5270
TH1.cxx:5271
TH1.cxx:5272
TH1.cxx:5273
TH1.cxx:5274
TH1.cxx:5275
TH1.cxx:5276
TH1.cxx:5277
TH1.cxx:5278
TH1.cxx:5279
TH1.cxx:5280
TH1.cxx:5281
TH1.cxx:5282
TH1.cxx:5283
TH1.cxx:5284
TH1.cxx:5285
TH1.cxx:5286
TH1.cxx:5287
TH1.cxx:5288
TH1.cxx:5289
TH1.cxx:5290
TH1.cxx:5291
TH1.cxx:5292
TH1.cxx:5293
TH1.cxx:5294
TH1.cxx:5295
TH1.cxx:5296
TH1.cxx:5297
TH1.cxx:5298
TH1.cxx:5299
TH1.cxx:5300
TH1.cxx:5301
TH1.cxx:5302
TH1.cxx:5303
TH1.cxx:5304
TH1.cxx:5305
TH1.cxx:5306
TH1.cxx:5307
TH1.cxx:5308
TH1.cxx:5309
TH1.cxx:5310
TH1.cxx:5311
TH1.cxx:5312
TH1.cxx:5313
TH1.cxx:5314
TH1.cxx:5315
TH1.cxx:5316
TH1.cxx:5317
TH1.cxx:5318
TH1.cxx:5319
TH1.cxx:5320
TH1.cxx:5321
TH1.cxx:5322
TH1.cxx:5323
TH1.cxx:5324
TH1.cxx:5325
TH1.cxx:5326
TH1.cxx:5327
TH1.cxx:5328
TH1.cxx:5329
TH1.cxx:5330
TH1.cxx:5331
TH1.cxx:5332
TH1.cxx:5333
TH1.cxx:5334
TH1.cxx:5335
TH1.cxx:5336
TH1.cxx:5337
TH1.cxx:5338
TH1.cxx:5339
TH1.cxx:5340
TH1.cxx:5341
TH1.cxx:5342
TH1.cxx:5343
TH1.cxx:5344
TH1.cxx:5345
TH1.cxx:5346
TH1.cxx:5347
TH1.cxx:5348
TH1.cxx:5349
TH1.cxx:5350
TH1.cxx:5351
TH1.cxx:5352
TH1.cxx:5353
TH1.cxx:5354
TH1.cxx:5355
TH1.cxx:5356
TH1.cxx:5357
TH1.cxx:5358
TH1.cxx:5359
TH1.cxx:5360
TH1.cxx:5361
TH1.cxx:5362
TH1.cxx:5363
TH1.cxx:5364
TH1.cxx:5365
TH1.cxx:5366
TH1.cxx:5367
TH1.cxx:5368
TH1.cxx:5369
TH1.cxx:5370
TH1.cxx:5371
TH1.cxx:5372
TH1.cxx:5373
TH1.cxx:5374
TH1.cxx:5375
TH1.cxx:5376
TH1.cxx:5377
TH1.cxx:5378
TH1.cxx:5379
TH1.cxx:5380
TH1.cxx:5381
TH1.cxx:5382
TH1.cxx:5383
TH1.cxx:5384
TH1.cxx:5385
TH1.cxx:5386
TH1.cxx:5387
TH1.cxx:5388
TH1.cxx:5389
TH1.cxx:5390
TH1.cxx:5391
TH1.cxx:5392
TH1.cxx:5393
TH1.cxx:5394
TH1.cxx:5395
TH1.cxx:5396
TH1.cxx:5397
TH1.cxx:5398
TH1.cxx:5399
TH1.cxx:5400
TH1.cxx:5401
TH1.cxx:5402
TH1.cxx:5403
TH1.cxx:5404
TH1.cxx:5405
TH1.cxx:5406
TH1.cxx:5407
TH1.cxx:5408
TH1.cxx:5409
TH1.cxx:5410
TH1.cxx:5411
TH1.cxx:5412
TH1.cxx:5413
TH1.cxx:5414
TH1.cxx:5415
TH1.cxx:5416
TH1.cxx:5417
TH1.cxx:5418
TH1.cxx:5419
TH1.cxx:5420
TH1.cxx:5421
TH1.cxx:5422
TH1.cxx:5423
TH1.cxx:5424
TH1.cxx:5425
TH1.cxx:5426
TH1.cxx:5427
TH1.cxx:5428
TH1.cxx:5429
TH1.cxx:5430
TH1.cxx:5431
TH1.cxx:5432
TH1.cxx:5433
TH1.cxx:5434
TH1.cxx:5435
TH1.cxx:5436
TH1.cxx:5437
TH1.cxx:5438
TH1.cxx:5439
TH1.cxx:5440
TH1.cxx:5441
TH1.cxx:5442
TH1.cxx:5443
TH1.cxx:5444
TH1.cxx:5445
TH1.cxx:5446
TH1.cxx:5447
TH1.cxx:5448
TH1.cxx:5449
TH1.cxx:5450
TH1.cxx:5451
TH1.cxx:5452
TH1.cxx:5453
TH1.cxx:5454
TH1.cxx:5455
TH1.cxx:5456
TH1.cxx:5457
TH1.cxx:5458
TH1.cxx:5459
TH1.cxx:5460
TH1.cxx:5461
TH1.cxx:5462
TH1.cxx:5463
TH1.cxx:5464
TH1.cxx:5465
TH1.cxx:5466
TH1.cxx:5467
TH1.cxx:5468
TH1.cxx:5469
TH1.cxx:5470
TH1.cxx:5471
TH1.cxx:5472
TH1.cxx:5473
TH1.cxx:5474
TH1.cxx:5475
TH1.cxx:5476
TH1.cxx:5477
TH1.cxx:5478
TH1.cxx:5479
TH1.cxx:5480
TH1.cxx:5481
TH1.cxx:5482
TH1.cxx:5483
TH1.cxx:5484
TH1.cxx:5485
TH1.cxx:5486
TH1.cxx:5487
TH1.cxx:5488
TH1.cxx:5489
TH1.cxx:5490
TH1.cxx:5491
TH1.cxx:5492
TH1.cxx:5493
TH1.cxx:5494
TH1.cxx:5495
TH1.cxx:5496
TH1.cxx:5497
TH1.cxx:5498
TH1.cxx:5499
TH1.cxx:5500
TH1.cxx:5501
TH1.cxx:5502
TH1.cxx:5503
TH1.cxx:5504
TH1.cxx:5505
TH1.cxx:5506
TH1.cxx:5507
TH1.cxx:5508
TH1.cxx:5509
TH1.cxx:5510
TH1.cxx:5511
TH1.cxx:5512
TH1.cxx:5513
TH1.cxx:5514
TH1.cxx:5515
TH1.cxx:5516
TH1.cxx:5517
TH1.cxx:5518
TH1.cxx:5519
TH1.cxx:5520
TH1.cxx:5521
TH1.cxx:5522
TH1.cxx:5523
TH1.cxx:5524
TH1.cxx:5525
TH1.cxx:5526
TH1.cxx:5527
TH1.cxx:5528
TH1.cxx:5529
TH1.cxx:5530
TH1.cxx:5531
TH1.cxx:5532
TH1.cxx:5533
TH1.cxx:5534
TH1.cxx:5535
TH1.cxx:5536
TH1.cxx:5537
TH1.cxx:5538
TH1.cxx:5539
TH1.cxx:5540
TH1.cxx:5541
TH1.cxx:5542
TH1.cxx:5543
TH1.cxx:5544
TH1.cxx:5545
TH1.cxx:5546
TH1.cxx:5547
TH1.cxx:5548
TH1.cxx:5549
TH1.cxx:5550
TH1.cxx:5551
TH1.cxx:5552
TH1.cxx:5553
TH1.cxx:5554
TH1.cxx:5555
TH1.cxx:5556
TH1.cxx:5557
TH1.cxx:5558
TH1.cxx:5559
TH1.cxx:5560
TH1.cxx:5561
TH1.cxx:5562
TH1.cxx:5563
TH1.cxx:5564
TH1.cxx:5565
TH1.cxx:5566
TH1.cxx:5567
TH1.cxx:5568
TH1.cxx:5569
TH1.cxx:5570
TH1.cxx:5571
TH1.cxx:5572
TH1.cxx:5573
TH1.cxx:5574
TH1.cxx:5575
TH1.cxx:5576
TH1.cxx:5577
TH1.cxx:5578
TH1.cxx:5579
TH1.cxx:5580
TH1.cxx:5581
TH1.cxx:5582
TH1.cxx:5583
TH1.cxx:5584
TH1.cxx:5585
TH1.cxx:5586
TH1.cxx:5587
TH1.cxx:5588
TH1.cxx:5589
TH1.cxx:5590
TH1.cxx:5591
TH1.cxx:5592
TH1.cxx:5593
TH1.cxx:5594
TH1.cxx:5595
TH1.cxx:5596
TH1.cxx:5597
TH1.cxx:5598
TH1.cxx:5599
TH1.cxx:5600
TH1.cxx:5601
TH1.cxx:5602
TH1.cxx:5603
TH1.cxx:5604
TH1.cxx:5605
TH1.cxx:5606
TH1.cxx:5607
TH1.cxx:5608
TH1.cxx:5609
TH1.cxx:5610
TH1.cxx:5611
TH1.cxx:5612
TH1.cxx:5613
TH1.cxx:5614
TH1.cxx:5615
TH1.cxx:5616
TH1.cxx:5617
TH1.cxx:5618
TH1.cxx:5619
TH1.cxx:5620
TH1.cxx:5621
TH1.cxx:5622
TH1.cxx:5623
TH1.cxx:5624
TH1.cxx:5625
TH1.cxx:5626
TH1.cxx:5627
TH1.cxx:5628
TH1.cxx:5629
TH1.cxx:5630
TH1.cxx:5631
TH1.cxx:5632
TH1.cxx:5633
TH1.cxx:5634
TH1.cxx:5635
TH1.cxx:5636
TH1.cxx:5637
TH1.cxx:5638
TH1.cxx:5639
TH1.cxx:5640
TH1.cxx:5641
TH1.cxx:5642
TH1.cxx:5643
TH1.cxx:5644
TH1.cxx:5645
TH1.cxx:5646
TH1.cxx:5647
TH1.cxx:5648
TH1.cxx:5649
TH1.cxx:5650
TH1.cxx:5651
TH1.cxx:5652
TH1.cxx:5653
TH1.cxx:5654
TH1.cxx:5655
TH1.cxx:5656
TH1.cxx:5657
TH1.cxx:5658
TH1.cxx:5659
TH1.cxx:5660
TH1.cxx:5661
TH1.cxx:5662
TH1.cxx:5663
TH1.cxx:5664
TH1.cxx:5665
TH1.cxx:5666
TH1.cxx:5667
TH1.cxx:5668
TH1.cxx:5669
TH1.cxx:5670
TH1.cxx:5671
TH1.cxx:5672
TH1.cxx:5673
TH1.cxx:5674
TH1.cxx:5675
TH1.cxx:5676
TH1.cxx:5677
TH1.cxx:5678
TH1.cxx:5679
TH1.cxx:5680
TH1.cxx:5681
TH1.cxx:5682
TH1.cxx:5683
TH1.cxx:5684
TH1.cxx:5685
TH1.cxx:5686
TH1.cxx:5687
TH1.cxx:5688
TH1.cxx:5689
TH1.cxx:5690
TH1.cxx:5691
TH1.cxx:5692
TH1.cxx:5693
TH1.cxx:5694
TH1.cxx:5695
TH1.cxx:5696
TH1.cxx:5697
TH1.cxx:5698
TH1.cxx:5699
TH1.cxx:5700
TH1.cxx:5701
TH1.cxx:5702
TH1.cxx:5703
TH1.cxx:5704
TH1.cxx:5705
TH1.cxx:5706
TH1.cxx:5707
TH1.cxx:5708
TH1.cxx:5709
TH1.cxx:5710
TH1.cxx:5711
TH1.cxx:5712
TH1.cxx:5713
TH1.cxx:5714
TH1.cxx:5715
TH1.cxx:5716
TH1.cxx:5717
TH1.cxx:5718
TH1.cxx:5719
TH1.cxx:5720
TH1.cxx:5721
TH1.cxx:5722
TH1.cxx:5723
TH1.cxx:5724
TH1.cxx:5725
TH1.cxx:5726
TH1.cxx:5727
TH1.cxx:5728
TH1.cxx:5729
TH1.cxx:5730
TH1.cxx:5731
TH1.cxx:5732
TH1.cxx:5733
TH1.cxx:5734
TH1.cxx:5735
TH1.cxx:5736
TH1.cxx:5737
TH1.cxx:5738
TH1.cxx:5739
TH1.cxx:5740
TH1.cxx:5741
TH1.cxx:5742
TH1.cxx:5743
TH1.cxx:5744
TH1.cxx:5745
TH1.cxx:5746
TH1.cxx:5747
TH1.cxx:5748
TH1.cxx:5749
TH1.cxx:5750
TH1.cxx:5751
TH1.cxx:5752
TH1.cxx:5753
TH1.cxx:5754
TH1.cxx:5755
TH1.cxx:5756
TH1.cxx:5757
TH1.cxx:5758
TH1.cxx:5759
TH1.cxx:5760
TH1.cxx:5761
TH1.cxx:5762
TH1.cxx:5763
TH1.cxx:5764
TH1.cxx:5765
TH1.cxx:5766
TH1.cxx:5767
TH1.cxx:5768
TH1.cxx:5769
TH1.cxx:5770
TH1.cxx:5771
TH1.cxx:5772
TH1.cxx:5773
TH1.cxx:5774
TH1.cxx:5775
TH1.cxx:5776
TH1.cxx:5777
TH1.cxx:5778
TH1.cxx:5779
TH1.cxx:5780
TH1.cxx:5781
TH1.cxx:5782
TH1.cxx:5783
TH1.cxx:5784
TH1.cxx:5785
TH1.cxx:5786
TH1.cxx:5787
TH1.cxx:5788
TH1.cxx:5789
TH1.cxx:5790
TH1.cxx:5791
TH1.cxx:5792
TH1.cxx:5793
TH1.cxx:5794
TH1.cxx:5795
TH1.cxx:5796
TH1.cxx:5797
TH1.cxx:5798
TH1.cxx:5799
TH1.cxx:5800
TH1.cxx:5801
TH1.cxx:5802
TH1.cxx:5803
TH1.cxx:5804
TH1.cxx:5805
TH1.cxx:5806
TH1.cxx:5807
TH1.cxx:5808
TH1.cxx:5809
TH1.cxx:5810
TH1.cxx:5811
TH1.cxx:5812
TH1.cxx:5813
TH1.cxx:5814
TH1.cxx:5815
TH1.cxx:5816
TH1.cxx:5817
TH1.cxx:5818
TH1.cxx:5819
TH1.cxx:5820
TH1.cxx:5821
TH1.cxx:5822
TH1.cxx:5823
TH1.cxx:5824
TH1.cxx:5825
TH1.cxx:5826
TH1.cxx:5827
TH1.cxx:5828
TH1.cxx:5829
TH1.cxx:5830
TH1.cxx:5831
TH1.cxx:5832
TH1.cxx:5833
TH1.cxx:5834
TH1.cxx:5835
TH1.cxx:5836
TH1.cxx:5837
TH1.cxx:5838
TH1.cxx:5839
TH1.cxx:5840
TH1.cxx:5841
TH1.cxx:5842
TH1.cxx:5843
TH1.cxx:5844
TH1.cxx:5845
TH1.cxx:5846
TH1.cxx:5847
TH1.cxx:5848
TH1.cxx:5849
TH1.cxx:5850
TH1.cxx:5851
TH1.cxx:5852
TH1.cxx:5853
TH1.cxx:5854
TH1.cxx:5855
TH1.cxx:5856
TH1.cxx:5857
TH1.cxx:5858
TH1.cxx:5859
TH1.cxx:5860
TH1.cxx:5861
TH1.cxx:5862
TH1.cxx:5863
TH1.cxx:5864
TH1.cxx:5865
TH1.cxx:5866
TH1.cxx:5867
TH1.cxx:5868
TH1.cxx:5869
TH1.cxx:5870
TH1.cxx:5871
TH1.cxx:5872
TH1.cxx:5873
TH1.cxx:5874
TH1.cxx:5875
TH1.cxx:5876
TH1.cxx:5877
TH1.cxx:5878
TH1.cxx:5879
TH1.cxx:5880
TH1.cxx:5881
TH1.cxx:5882
TH1.cxx:5883
TH1.cxx:5884
TH1.cxx:5885
TH1.cxx:5886
TH1.cxx:5887
TH1.cxx:5888
TH1.cxx:5889
TH1.cxx:5890
TH1.cxx:5891
TH1.cxx:5892
TH1.cxx:5893
TH1.cxx:5894
TH1.cxx:5895
TH1.cxx:5896
TH1.cxx:5897
TH1.cxx:5898
TH1.cxx:5899
TH1.cxx:5900
TH1.cxx:5901
TH1.cxx:5902
TH1.cxx:5903
TH1.cxx:5904
TH1.cxx:5905
TH1.cxx:5906
TH1.cxx:5907
TH1.cxx:5908
TH1.cxx:5909
TH1.cxx:5910
TH1.cxx:5911
TH1.cxx:5912
TH1.cxx:5913
TH1.cxx:5914
TH1.cxx:5915
TH1.cxx:5916
TH1.cxx:5917
TH1.cxx:5918
TH1.cxx:5919
TH1.cxx:5920
TH1.cxx:5921
TH1.cxx:5922
TH1.cxx:5923
TH1.cxx:5924
TH1.cxx:5925
TH1.cxx:5926
TH1.cxx:5927
TH1.cxx:5928
TH1.cxx:5929
TH1.cxx:5930
TH1.cxx:5931
TH1.cxx:5932
TH1.cxx:5933
TH1.cxx:5934
TH1.cxx:5935
TH1.cxx:5936
TH1.cxx:5937
TH1.cxx:5938
TH1.cxx:5939
TH1.cxx:5940
TH1.cxx:5941
TH1.cxx:5942
TH1.cxx:5943
TH1.cxx:5944
TH1.cxx:5945
TH1.cxx:5946
TH1.cxx:5947
TH1.cxx:5948
TH1.cxx:5949
TH1.cxx:5950
TH1.cxx:5951
TH1.cxx:5952
TH1.cxx:5953
TH1.cxx:5954
TH1.cxx:5955
TH1.cxx:5956
TH1.cxx:5957
TH1.cxx:5958
TH1.cxx:5959
TH1.cxx:5960
TH1.cxx:5961
TH1.cxx:5962
TH1.cxx:5963
TH1.cxx:5964
TH1.cxx:5965
TH1.cxx:5966
TH1.cxx:5967
TH1.cxx:5968
TH1.cxx:5969
TH1.cxx:5970
TH1.cxx:5971
TH1.cxx:5972
TH1.cxx:5973
TH1.cxx:5974
TH1.cxx:5975
TH1.cxx:5976
TH1.cxx:5977
TH1.cxx:5978
TH1.cxx:5979
TH1.cxx:5980
TH1.cxx:5981
TH1.cxx:5982
TH1.cxx:5983
TH1.cxx:5984
TH1.cxx:5985
TH1.cxx:5986
TH1.cxx:5987
TH1.cxx:5988
TH1.cxx:5989
TH1.cxx:5990
TH1.cxx:5991
TH1.cxx:5992
TH1.cxx:5993
TH1.cxx:5994
TH1.cxx:5995
TH1.cxx:5996
TH1.cxx:5997
TH1.cxx:5998
TH1.cxx:5999
TH1.cxx:6000
TH1.cxx:6001
TH1.cxx:6002
TH1.cxx:6003
TH1.cxx:6004
TH1.cxx:6005
TH1.cxx:6006
TH1.cxx:6007
TH1.cxx:6008
TH1.cxx:6009
TH1.cxx:6010
TH1.cxx:6011
TH1.cxx:6012
TH1.cxx:6013
TH1.cxx:6014
TH1.cxx:6015
TH1.cxx:6016
TH1.cxx:6017
TH1.cxx:6018
TH1.cxx:6019
TH1.cxx:6020
TH1.cxx:6021
TH1.cxx:6022
TH1.cxx:6023
TH1.cxx:6024
TH1.cxx:6025
TH1.cxx:6026
TH1.cxx:6027
TH1.cxx:6028
TH1.cxx:6029
TH1.cxx:6030
TH1.cxx:6031
TH1.cxx:6032
TH1.cxx:6033
TH1.cxx:6034
TH1.cxx:6035
TH1.cxx:6036
TH1.cxx:6037
TH1.cxx:6038
TH1.cxx:6039
TH1.cxx:6040
TH1.cxx:6041
TH1.cxx:6042
TH1.cxx:6043
TH1.cxx:6044
TH1.cxx:6045
TH1.cxx:6046
TH1.cxx:6047
TH1.cxx:6048
TH1.cxx:6049
TH1.cxx:6050
TH1.cxx:6051
TH1.cxx:6052
TH1.cxx:6053
TH1.cxx:6054
TH1.cxx:6055
TH1.cxx:6056
TH1.cxx:6057
TH1.cxx:6058
TH1.cxx:6059
TH1.cxx:6060
TH1.cxx:6061
TH1.cxx:6062
TH1.cxx:6063
TH1.cxx:6064
TH1.cxx:6065
TH1.cxx:6066
TH1.cxx:6067
TH1.cxx:6068
TH1.cxx:6069
TH1.cxx:6070
TH1.cxx:6071
TH1.cxx:6072
TH1.cxx:6073
TH1.cxx:6074
TH1.cxx:6075
TH1.cxx:6076
TH1.cxx:6077
TH1.cxx:6078
TH1.cxx:6079
TH1.cxx:6080
TH1.cxx:6081
TH1.cxx:6082
TH1.cxx:6083
TH1.cxx:6084
TH1.cxx:6085
TH1.cxx:6086
TH1.cxx:6087
TH1.cxx:6088
TH1.cxx:6089
TH1.cxx:6090
TH1.cxx:6091
TH1.cxx:6092
TH1.cxx:6093
TH1.cxx:6094
TH1.cxx:6095
TH1.cxx:6096
TH1.cxx:6097
TH1.cxx:6098
TH1.cxx:6099
TH1.cxx:6100
TH1.cxx:6101
TH1.cxx:6102
TH1.cxx:6103
TH1.cxx:6104
TH1.cxx:6105
TH1.cxx:6106
TH1.cxx:6107
TH1.cxx:6108
TH1.cxx:6109
TH1.cxx:6110
TH1.cxx:6111
TH1.cxx:6112
TH1.cxx:6113
TH1.cxx:6114
TH1.cxx:6115
TH1.cxx:6116
TH1.cxx:6117
TH1.cxx:6118
TH1.cxx:6119
TH1.cxx:6120
TH1.cxx:6121
TH1.cxx:6122
TH1.cxx:6123
TH1.cxx:6124
TH1.cxx:6125
TH1.cxx:6126
TH1.cxx:6127
TH1.cxx:6128
TH1.cxx:6129
TH1.cxx:6130
TH1.cxx:6131
TH1.cxx:6132
TH1.cxx:6133
TH1.cxx:6134
TH1.cxx:6135
TH1.cxx:6136
TH1.cxx:6137
TH1.cxx:6138
TH1.cxx:6139
TH1.cxx:6140
TH1.cxx:6141
TH1.cxx:6142
TH1.cxx:6143
TH1.cxx:6144
TH1.cxx:6145
TH1.cxx:6146
TH1.cxx:6147
TH1.cxx:6148
TH1.cxx:6149
TH1.cxx:6150
TH1.cxx:6151
TH1.cxx:6152
TH1.cxx:6153
TH1.cxx:6154
TH1.cxx:6155
TH1.cxx:6156
TH1.cxx:6157
TH1.cxx:6158
TH1.cxx:6159
TH1.cxx:6160
TH1.cxx:6161
TH1.cxx:6162
TH1.cxx:6163
TH1.cxx:6164
TH1.cxx:6165
TH1.cxx:6166
TH1.cxx:6167
TH1.cxx:6168
TH1.cxx:6169
TH1.cxx:6170
TH1.cxx:6171
TH1.cxx:6172
TH1.cxx:6173
TH1.cxx:6174
TH1.cxx:6175
TH1.cxx:6176
TH1.cxx:6177
TH1.cxx:6178
TH1.cxx:6179
TH1.cxx:6180
TH1.cxx:6181
TH1.cxx:6182
TH1.cxx:6183
TH1.cxx:6184
TH1.cxx:6185
TH1.cxx:6186
TH1.cxx:6187
TH1.cxx:6188
TH1.cxx:6189
TH1.cxx:6190
TH1.cxx:6191
TH1.cxx:6192
TH1.cxx:6193
TH1.cxx:6194
TH1.cxx:6195
TH1.cxx:6196
TH1.cxx:6197
TH1.cxx:6198
TH1.cxx:6199
TH1.cxx:6200
TH1.cxx:6201
TH1.cxx:6202
TH1.cxx:6203
TH1.cxx:6204
TH1.cxx:6205
TH1.cxx:6206
TH1.cxx:6207
TH1.cxx:6208
TH1.cxx:6209
TH1.cxx:6210
TH1.cxx:6211
TH1.cxx:6212
TH1.cxx:6213
TH1.cxx:6214
TH1.cxx:6215
TH1.cxx:6216
TH1.cxx:6217
TH1.cxx:6218
TH1.cxx:6219
TH1.cxx:6220
TH1.cxx:6221
TH1.cxx:6222
TH1.cxx:6223
TH1.cxx:6224
TH1.cxx:6225
TH1.cxx:6226
TH1.cxx:6227
TH1.cxx:6228
TH1.cxx:6229
TH1.cxx:6230
TH1.cxx:6231
TH1.cxx:6232
TH1.cxx:6233
TH1.cxx:6234
TH1.cxx:6235
TH1.cxx:6236
TH1.cxx:6237
TH1.cxx:6238
TH1.cxx:6239
TH1.cxx:6240
TH1.cxx:6241
TH1.cxx:6242
TH1.cxx:6243
TH1.cxx:6244
TH1.cxx:6245
TH1.cxx:6246
TH1.cxx:6247
TH1.cxx:6248
TH1.cxx:6249
TH1.cxx:6250
TH1.cxx:6251
TH1.cxx:6252
TH1.cxx:6253
TH1.cxx:6254
TH1.cxx:6255
TH1.cxx:6256
TH1.cxx:6257
TH1.cxx:6258
TH1.cxx:6259
TH1.cxx:6260
TH1.cxx:6261
TH1.cxx:6262
TH1.cxx:6263
TH1.cxx:6264
TH1.cxx:6265
TH1.cxx:6266
TH1.cxx:6267
TH1.cxx:6268
TH1.cxx:6269
TH1.cxx:6270
TH1.cxx:6271
TH1.cxx:6272
TH1.cxx:6273
TH1.cxx:6274
TH1.cxx:6275
TH1.cxx:6276
TH1.cxx:6277
TH1.cxx:6278
TH1.cxx:6279
TH1.cxx:6280
TH1.cxx:6281
TH1.cxx:6282
TH1.cxx:6283
TH1.cxx:6284
TH1.cxx:6285
TH1.cxx:6286
TH1.cxx:6287
TH1.cxx:6288
TH1.cxx:6289
TH1.cxx:6290
TH1.cxx:6291
TH1.cxx:6292
TH1.cxx:6293
TH1.cxx:6294
TH1.cxx:6295
TH1.cxx:6296
TH1.cxx:6297
TH1.cxx:6298
TH1.cxx:6299
TH1.cxx:6300
TH1.cxx:6301
TH1.cxx:6302
TH1.cxx:6303
TH1.cxx:6304
TH1.cxx:6305
TH1.cxx:6306
TH1.cxx:6307
TH1.cxx:6308
TH1.cxx:6309
TH1.cxx:6310
TH1.cxx:6311
TH1.cxx:6312
TH1.cxx:6313
TH1.cxx:6314
TH1.cxx:6315
TH1.cxx:6316
TH1.cxx:6317
TH1.cxx:6318
TH1.cxx:6319
TH1.cxx:6320
TH1.cxx:6321
TH1.cxx:6322
TH1.cxx:6323
TH1.cxx:6324
TH1.cxx:6325
TH1.cxx:6326
TH1.cxx:6327
TH1.cxx:6328
TH1.cxx:6329
TH1.cxx:6330
TH1.cxx:6331
TH1.cxx:6332
TH1.cxx:6333
TH1.cxx:6334
TH1.cxx:6335
TH1.cxx:6336
TH1.cxx:6337
TH1.cxx:6338
TH1.cxx:6339
TH1.cxx:6340
TH1.cxx:6341
TH1.cxx:6342
TH1.cxx:6343
TH1.cxx:6344
TH1.cxx:6345
TH1.cxx:6346
TH1.cxx:6347
TH1.cxx:6348
TH1.cxx:6349
TH1.cxx:6350
TH1.cxx:6351
TH1.cxx:6352
TH1.cxx:6353
TH1.cxx:6354
TH1.cxx:6355
TH1.cxx:6356
TH1.cxx:6357
TH1.cxx:6358
TH1.cxx:6359
TH1.cxx:6360
TH1.cxx:6361
TH1.cxx:6362
TH1.cxx:6363
TH1.cxx:6364
TH1.cxx:6365
TH1.cxx:6366
TH1.cxx:6367
TH1.cxx:6368
TH1.cxx:6369
TH1.cxx:6370
TH1.cxx:6371
TH1.cxx:6372
TH1.cxx:6373
TH1.cxx:6374
TH1.cxx:6375
TH1.cxx:6376
TH1.cxx:6377
TH1.cxx:6378
TH1.cxx:6379
TH1.cxx:6380
TH1.cxx:6381
TH1.cxx:6382
TH1.cxx:6383
TH1.cxx:6384
TH1.cxx:6385
TH1.cxx:6386
TH1.cxx:6387
TH1.cxx:6388
TH1.cxx:6389
TH1.cxx:6390
TH1.cxx:6391
TH1.cxx:6392
TH1.cxx:6393
TH1.cxx:6394
TH1.cxx:6395
TH1.cxx:6396
TH1.cxx:6397
TH1.cxx:6398
TH1.cxx:6399
TH1.cxx:6400
TH1.cxx:6401
TH1.cxx:6402
TH1.cxx:6403
TH1.cxx:6404
TH1.cxx:6405
TH1.cxx:6406
TH1.cxx:6407
TH1.cxx:6408
TH1.cxx:6409
TH1.cxx:6410
TH1.cxx:6411
TH1.cxx:6412
TH1.cxx:6413
TH1.cxx:6414
TH1.cxx:6415
TH1.cxx:6416
TH1.cxx:6417
TH1.cxx:6418
TH1.cxx:6419
TH1.cxx:6420
TH1.cxx:6421
TH1.cxx:6422
TH1.cxx:6423
TH1.cxx:6424
TH1.cxx:6425
TH1.cxx:6426
TH1.cxx:6427
TH1.cxx:6428
TH1.cxx:6429
TH1.cxx:6430
TH1.cxx:6431
TH1.cxx:6432
TH1.cxx:6433
TH1.cxx:6434
TH1.cxx:6435
TH1.cxx:6436
TH1.cxx:6437
TH1.cxx:6438
TH1.cxx:6439
TH1.cxx:6440
TH1.cxx:6441
TH1.cxx:6442
TH1.cxx:6443
TH1.cxx:6444
TH1.cxx:6445
TH1.cxx:6446
TH1.cxx:6447
TH1.cxx:6448
TH1.cxx:6449
TH1.cxx:6450
TH1.cxx:6451
TH1.cxx:6452
TH1.cxx:6453
TH1.cxx:6454
TH1.cxx:6455
TH1.cxx:6456
TH1.cxx:6457
TH1.cxx:6458
TH1.cxx:6459
TH1.cxx:6460
TH1.cxx:6461
TH1.cxx:6462
TH1.cxx:6463
TH1.cxx:6464
TH1.cxx:6465
TH1.cxx:6466
TH1.cxx:6467
TH1.cxx:6468
TH1.cxx:6469
TH1.cxx:6470
TH1.cxx:6471
TH1.cxx:6472
TH1.cxx:6473
TH1.cxx:6474
TH1.cxx:6475
TH1.cxx:6476
TH1.cxx:6477
TH1.cxx:6478
TH1.cxx:6479
TH1.cxx:6480
TH1.cxx:6481
TH1.cxx:6482
TH1.cxx:6483
TH1.cxx:6484
TH1.cxx:6485
TH1.cxx:6486
TH1.cxx:6487
TH1.cxx:6488
TH1.cxx:6489
TH1.cxx:6490
TH1.cxx:6491
TH1.cxx:6492
TH1.cxx:6493
TH1.cxx:6494
TH1.cxx:6495
TH1.cxx:6496
TH1.cxx:6497
TH1.cxx:6498
TH1.cxx:6499
TH1.cxx:6500
TH1.cxx:6501
TH1.cxx:6502
TH1.cxx:6503
TH1.cxx:6504
TH1.cxx:6505
TH1.cxx:6506
TH1.cxx:6507
TH1.cxx:6508
TH1.cxx:6509
TH1.cxx:6510
TH1.cxx:6511
TH1.cxx:6512
TH1.cxx:6513
TH1.cxx:6514
TH1.cxx:6515
TH1.cxx:6516
TH1.cxx:6517
TH1.cxx:6518
TH1.cxx:6519
TH1.cxx:6520
TH1.cxx:6521
TH1.cxx:6522
TH1.cxx:6523
TH1.cxx:6524
TH1.cxx:6525
TH1.cxx:6526
TH1.cxx:6527
TH1.cxx:6528
TH1.cxx:6529
TH1.cxx:6530
TH1.cxx:6531
TH1.cxx:6532
TH1.cxx:6533
TH1.cxx:6534
TH1.cxx:6535
TH1.cxx:6536
TH1.cxx:6537
TH1.cxx:6538
TH1.cxx:6539
TH1.cxx:6540
TH1.cxx:6541
TH1.cxx:6542
TH1.cxx:6543
TH1.cxx:6544
TH1.cxx:6545
TH1.cxx:6546
TH1.cxx:6547
TH1.cxx:6548
TH1.cxx:6549
TH1.cxx:6550
TH1.cxx:6551
TH1.cxx:6552
TH1.cxx:6553
TH1.cxx:6554
TH1.cxx:6555
TH1.cxx:6556
TH1.cxx:6557
TH1.cxx:6558
TH1.cxx:6559
TH1.cxx:6560
TH1.cxx:6561
TH1.cxx:6562
TH1.cxx:6563
TH1.cxx:6564
TH1.cxx:6565
TH1.cxx:6566
TH1.cxx:6567
TH1.cxx:6568
TH1.cxx:6569
TH1.cxx:6570
TH1.cxx:6571
TH1.cxx:6572
TH1.cxx:6573
TH1.cxx:6574
TH1.cxx:6575
TH1.cxx:6576
TH1.cxx:6577
TH1.cxx:6578
TH1.cxx:6579
TH1.cxx:6580
TH1.cxx:6581
TH1.cxx:6582
TH1.cxx:6583
TH1.cxx:6584
TH1.cxx:6585
TH1.cxx:6586
TH1.cxx:6587
TH1.cxx:6588
TH1.cxx:6589
TH1.cxx:6590
TH1.cxx:6591
TH1.cxx:6592
TH1.cxx:6593
TH1.cxx:6594
TH1.cxx:6595
TH1.cxx:6596
TH1.cxx:6597
TH1.cxx:6598
TH1.cxx:6599
TH1.cxx:6600
TH1.cxx:6601
TH1.cxx:6602
TH1.cxx:6603
TH1.cxx:6604
TH1.cxx:6605
TH1.cxx:6606
TH1.cxx:6607
TH1.cxx:6608
TH1.cxx:6609
TH1.cxx:6610
TH1.cxx:6611
TH1.cxx:6612
TH1.cxx:6613
TH1.cxx:6614
TH1.cxx:6615
TH1.cxx:6616
TH1.cxx:6617
TH1.cxx:6618
TH1.cxx:6619
TH1.cxx:6620
TH1.cxx:6621
TH1.cxx:6622
TH1.cxx:6623
TH1.cxx:6624
TH1.cxx:6625
TH1.cxx:6626
TH1.cxx:6627
TH1.cxx:6628
TH1.cxx:6629
TH1.cxx:6630
TH1.cxx:6631
TH1.cxx:6632
TH1.cxx:6633
TH1.cxx:6634
TH1.cxx:6635
TH1.cxx:6636
TH1.cxx:6637
TH1.cxx:6638
TH1.cxx:6639
TH1.cxx:6640
TH1.cxx:6641
TH1.cxx:6642
TH1.cxx:6643
TH1.cxx:6644
TH1.cxx:6645
TH1.cxx:6646
TH1.cxx:6647
TH1.cxx:6648
TH1.cxx:6649
TH1.cxx:6650
TH1.cxx:6651
TH1.cxx:6652
TH1.cxx:6653
TH1.cxx:6654
TH1.cxx:6655
TH1.cxx:6656
TH1.cxx:6657
TH1.cxx:6658
TH1.cxx:6659
TH1.cxx:6660
TH1.cxx:6661
TH1.cxx:6662
TH1.cxx:6663
TH1.cxx:6664
TH1.cxx:6665
TH1.cxx:6666
TH1.cxx:6667
TH1.cxx:6668
TH1.cxx:6669
TH1.cxx:6670
TH1.cxx:6671
TH1.cxx:6672
TH1.cxx:6673
TH1.cxx:6674
TH1.cxx:6675
TH1.cxx:6676
TH1.cxx:6677
TH1.cxx:6678
TH1.cxx:6679
TH1.cxx:6680
TH1.cxx:6681
TH1.cxx:6682
TH1.cxx:6683
TH1.cxx:6684
TH1.cxx:6685
TH1.cxx:6686
TH1.cxx:6687
TH1.cxx:6688
TH1.cxx:6689
TH1.cxx:6690
TH1.cxx:6691
TH1.cxx:6692
TH1.cxx:6693
TH1.cxx:6694
TH1.cxx:6695
TH1.cxx:6696
TH1.cxx:6697
TH1.cxx:6698
TH1.cxx:6699
TH1.cxx:6700
TH1.cxx:6701
TH1.cxx:6702
TH1.cxx:6703
TH1.cxx:6704
TH1.cxx:6705
TH1.cxx:6706
TH1.cxx:6707
TH1.cxx:6708
TH1.cxx:6709
TH1.cxx:6710
TH1.cxx:6711
TH1.cxx:6712
TH1.cxx:6713
TH1.cxx:6714
TH1.cxx:6715
TH1.cxx:6716
TH1.cxx:6717
TH1.cxx:6718
TH1.cxx:6719
TH1.cxx:6720
TH1.cxx:6721
TH1.cxx:6722
TH1.cxx:6723
TH1.cxx:6724
TH1.cxx:6725
TH1.cxx:6726
TH1.cxx:6727
TH1.cxx:6728
TH1.cxx:6729
TH1.cxx:6730
TH1.cxx:6731
TH1.cxx:6732
TH1.cxx:6733
TH1.cxx:6734
TH1.cxx:6735
TH1.cxx:6736
TH1.cxx:6737
TH1.cxx:6738
TH1.cxx:6739
TH1.cxx:6740
TH1.cxx:6741
TH1.cxx:6742
TH1.cxx:6743
TH1.cxx:6744
TH1.cxx:6745
TH1.cxx:6746
TH1.cxx:6747
TH1.cxx:6748
TH1.cxx:6749
TH1.cxx:6750
TH1.cxx:6751
TH1.cxx:6752
TH1.cxx:6753
TH1.cxx:6754
TH1.cxx:6755
TH1.cxx:6756
TH1.cxx:6757
TH1.cxx:6758
TH1.cxx:6759
TH1.cxx:6760
TH1.cxx:6761
TH1.cxx:6762
TH1.cxx:6763
TH1.cxx:6764
TH1.cxx:6765
TH1.cxx:6766
TH1.cxx:6767
TH1.cxx:6768
TH1.cxx:6769
TH1.cxx:6770
TH1.cxx:6771
TH1.cxx:6772
TH1.cxx:6773
TH1.cxx:6774
TH1.cxx:6775
TH1.cxx:6776
TH1.cxx:6777
TH1.cxx:6778
TH1.cxx:6779
TH1.cxx:6780
TH1.cxx:6781
TH1.cxx:6782
TH1.cxx:6783
TH1.cxx:6784
TH1.cxx:6785
TH1.cxx:6786
TH1.cxx:6787
TH1.cxx:6788
TH1.cxx:6789
TH1.cxx:6790
TH1.cxx:6791
TH1.cxx:6792
TH1.cxx:6793
TH1.cxx:6794
TH1.cxx:6795
TH1.cxx:6796
TH1.cxx:6797
TH1.cxx:6798
TH1.cxx:6799
TH1.cxx:6800
TH1.cxx:6801
TH1.cxx:6802
TH1.cxx:6803
TH1.cxx:6804
TH1.cxx:6805
TH1.cxx:6806
TH1.cxx:6807
TH1.cxx:6808
TH1.cxx:6809
TH1.cxx:6810
TH1.cxx:6811
TH1.cxx:6812
TH1.cxx:6813
TH1.cxx:6814
TH1.cxx:6815
TH1.cxx:6816
TH1.cxx:6817
TH1.cxx:6818
TH1.cxx:6819
TH1.cxx:6820
TH1.cxx:6821
TH1.cxx:6822
TH1.cxx:6823
TH1.cxx:6824
TH1.cxx:6825
TH1.cxx:6826
TH1.cxx:6827
TH1.cxx:6828
TH1.cxx:6829
TH1.cxx:6830
TH1.cxx:6831
TH1.cxx:6832
TH1.cxx:6833
TH1.cxx:6834
TH1.cxx:6835
TH1.cxx:6836
TH1.cxx:6837
TH1.cxx:6838
TH1.cxx:6839
TH1.cxx:6840
TH1.cxx:6841
TH1.cxx:6842
TH1.cxx:6843
TH1.cxx:6844
TH1.cxx:6845
TH1.cxx:6846
TH1.cxx:6847
TH1.cxx:6848
TH1.cxx:6849
TH1.cxx:6850
TH1.cxx:6851
TH1.cxx:6852
TH1.cxx:6853
TH1.cxx:6854
TH1.cxx:6855
TH1.cxx:6856
TH1.cxx:6857
TH1.cxx:6858
TH1.cxx:6859
TH1.cxx:6860
TH1.cxx:6861
TH1.cxx:6862
TH1.cxx:6863
TH1.cxx:6864
TH1.cxx:6865
TH1.cxx:6866
TH1.cxx:6867
TH1.cxx:6868
TH1.cxx:6869
TH1.cxx:6870
TH1.cxx:6871
TH1.cxx:6872
TH1.cxx:6873
TH1.cxx:6874
TH1.cxx:6875
TH1.cxx:6876
TH1.cxx:6877
TH1.cxx:6878
TH1.cxx:6879
TH1.cxx:6880
TH1.cxx:6881
TH1.cxx:6882
TH1.cxx:6883
TH1.cxx:6884
TH1.cxx:6885
TH1.cxx:6886
TH1.cxx:6887
TH1.cxx:6888
TH1.cxx:6889
TH1.cxx:6890
TH1.cxx:6891
TH1.cxx:6892
TH1.cxx:6893
TH1.cxx:6894
TH1.cxx:6895
TH1.cxx:6896
TH1.cxx:6897
TH1.cxx:6898
TH1.cxx:6899
TH1.cxx:6900
TH1.cxx:6901
TH1.cxx:6902
TH1.cxx:6903
TH1.cxx:6904
TH1.cxx:6905
TH1.cxx:6906
TH1.cxx:6907
TH1.cxx:6908
TH1.cxx:6909
TH1.cxx:6910
TH1.cxx:6911
TH1.cxx:6912
TH1.cxx:6913
TH1.cxx:6914
TH1.cxx:6915
TH1.cxx:6916
TH1.cxx:6917
TH1.cxx:6918
TH1.cxx:6919
TH1.cxx:6920
TH1.cxx:6921
TH1.cxx:6922
TH1.cxx:6923
TH1.cxx:6924
TH1.cxx:6925
TH1.cxx:6926
TH1.cxx:6927
TH1.cxx:6928
TH1.cxx:6929
TH1.cxx:6930
TH1.cxx:6931
TH1.cxx:6932
TH1.cxx:6933
TH1.cxx:6934
TH1.cxx:6935
TH1.cxx:6936
TH1.cxx:6937
TH1.cxx:6938
TH1.cxx:6939
TH1.cxx:6940
TH1.cxx:6941
TH1.cxx:6942
TH1.cxx:6943
TH1.cxx:6944
TH1.cxx:6945
TH1.cxx:6946
TH1.cxx:6947
TH1.cxx:6948
TH1.cxx:6949
TH1.cxx:6950
TH1.cxx:6951
TH1.cxx:6952
TH1.cxx:6953
TH1.cxx:6954
TH1.cxx:6955
TH1.cxx:6956
TH1.cxx:6957
TH1.cxx:6958
TH1.cxx:6959
TH1.cxx:6960
TH1.cxx:6961
TH1.cxx:6962
TH1.cxx:6963
TH1.cxx:6964
TH1.cxx:6965
TH1.cxx:6966
TH1.cxx:6967
TH1.cxx:6968
TH1.cxx:6969
TH1.cxx:6970
TH1.cxx:6971
TH1.cxx:6972
TH1.cxx:6973
TH1.cxx:6974
TH1.cxx:6975
TH1.cxx:6976
TH1.cxx:6977
TH1.cxx:6978
TH1.cxx:6979
TH1.cxx:6980
TH1.cxx:6981
TH1.cxx:6982
TH1.cxx:6983
TH1.cxx:6984
TH1.cxx:6985
TH1.cxx:6986
TH1.cxx:6987
TH1.cxx:6988
TH1.cxx:6989
TH1.cxx:6990
TH1.cxx:6991
TH1.cxx:6992
TH1.cxx:6993
TH1.cxx:6994
TH1.cxx:6995
TH1.cxx:6996
TH1.cxx:6997
TH1.cxx:6998
TH1.cxx:6999
TH1.cxx:7000
TH1.cxx:7001
TH1.cxx:7002
TH1.cxx:7003
TH1.cxx:7004
TH1.cxx:7005
TH1.cxx:7006
TH1.cxx:7007
TH1.cxx:7008
TH1.cxx:7009
TH1.cxx:7010
TH1.cxx:7011
TH1.cxx:7012
TH1.cxx:7013
TH1.cxx:7014
TH1.cxx:7015
TH1.cxx:7016
TH1.cxx:7017
TH1.cxx:7018
TH1.cxx:7019
TH1.cxx:7020
TH1.cxx:7021
TH1.cxx:7022
TH1.cxx:7023
TH1.cxx:7024
TH1.cxx:7025
TH1.cxx:7026
TH1.cxx:7027
TH1.cxx:7028
TH1.cxx:7029
TH1.cxx:7030
TH1.cxx:7031
TH1.cxx:7032
TH1.cxx:7033
TH1.cxx:7034
TH1.cxx:7035
TH1.cxx:7036
TH1.cxx:7037
TH1.cxx:7038
TH1.cxx:7039
TH1.cxx:7040
TH1.cxx:7041
TH1.cxx:7042
TH1.cxx:7043
TH1.cxx:7044
TH1.cxx:7045
TH1.cxx:7046
TH1.cxx:7047
TH1.cxx:7048
TH1.cxx:7049
TH1.cxx:7050
TH1.cxx:7051
TH1.cxx:7052
TH1.cxx:7053
TH1.cxx:7054
TH1.cxx:7055
TH1.cxx:7056
TH1.cxx:7057
TH1.cxx:7058
TH1.cxx:7059
TH1.cxx:7060
TH1.cxx:7061
TH1.cxx:7062
TH1.cxx:7063
TH1.cxx:7064
TH1.cxx:7065
TH1.cxx:7066
TH1.cxx:7067
TH1.cxx:7068
TH1.cxx:7069
TH1.cxx:7070
TH1.cxx:7071
TH1.cxx:7072
TH1.cxx:7073
TH1.cxx:7074
TH1.cxx:7075
TH1.cxx:7076
TH1.cxx:7077
TH1.cxx:7078
TH1.cxx:7079
TH1.cxx:7080
TH1.cxx:7081
TH1.cxx:7082
TH1.cxx:7083
TH1.cxx:7084
TH1.cxx:7085
TH1.cxx:7086
TH1.cxx:7087
TH1.cxx:7088
TH1.cxx:7089
TH1.cxx:7090
TH1.cxx:7091
TH1.cxx:7092
TH1.cxx:7093
TH1.cxx:7094
TH1.cxx:7095
TH1.cxx:7096
TH1.cxx:7097
TH1.cxx:7098
TH1.cxx:7099
TH1.cxx:7100
TH1.cxx:7101
TH1.cxx:7102
TH1.cxx:7103
TH1.cxx:7104
TH1.cxx:7105
TH1.cxx:7106
TH1.cxx:7107
TH1.cxx:7108
TH1.cxx:7109
TH1.cxx:7110
TH1.cxx:7111
TH1.cxx:7112
TH1.cxx:7113
TH1.cxx:7114
TH1.cxx:7115
TH1.cxx:7116
TH1.cxx:7117
TH1.cxx:7118
TH1.cxx:7119
TH1.cxx:7120
TH1.cxx:7121
TH1.cxx:7122
TH1.cxx:7123
TH1.cxx:7124
TH1.cxx:7125
TH1.cxx:7126
TH1.cxx:7127
TH1.cxx:7128
TH1.cxx:7129
TH1.cxx:7130
TH1.cxx:7131
TH1.cxx:7132
TH1.cxx:7133
TH1.cxx:7134
TH1.cxx:7135
TH1.cxx:7136
TH1.cxx:7137
TH1.cxx:7138
TH1.cxx:7139
TH1.cxx:7140
TH1.cxx:7141
TH1.cxx:7142
TH1.cxx:7143
TH1.cxx:7144
TH1.cxx:7145
TH1.cxx:7146
TH1.cxx:7147
TH1.cxx:7148
TH1.cxx:7149
TH1.cxx:7150
TH1.cxx:7151
TH1.cxx:7152
TH1.cxx:7153
TH1.cxx:7154
TH1.cxx:7155
TH1.cxx:7156
TH1.cxx:7157
TH1.cxx:7158
TH1.cxx:7159
TH1.cxx:7160
TH1.cxx:7161
TH1.cxx:7162
TH1.cxx:7163
TH1.cxx:7164
TH1.cxx:7165
TH1.cxx:7166
TH1.cxx:7167
TH1.cxx:7168
TH1.cxx:7169
TH1.cxx:7170
TH1.cxx:7171
TH1.cxx:7172
TH1.cxx:7173
TH1.cxx:7174
TH1.cxx:7175
TH1.cxx:7176
TH1.cxx:7177
TH1.cxx:7178
TH1.cxx:7179
TH1.cxx:7180
TH1.cxx:7181
TH1.cxx:7182
TH1.cxx:7183
TH1.cxx:7184
TH1.cxx:7185
TH1.cxx:7186
TH1.cxx:7187
TH1.cxx:7188
TH1.cxx:7189
TH1.cxx:7190
TH1.cxx:7191
TH1.cxx:7192
TH1.cxx:7193
TH1.cxx:7194
TH1.cxx:7195
TH1.cxx:7196
TH1.cxx:7197
TH1.cxx:7198
TH1.cxx:7199
TH1.cxx:7200
TH1.cxx:7201
TH1.cxx:7202
TH1.cxx:7203
TH1.cxx:7204
TH1.cxx:7205
TH1.cxx:7206
TH1.cxx:7207
TH1.cxx:7208
TH1.cxx:7209
TH1.cxx:7210
TH1.cxx:7211
TH1.cxx:7212
TH1.cxx:7213
TH1.cxx:7214
TH1.cxx:7215
TH1.cxx:7216
TH1.cxx:7217
TH1.cxx:7218
TH1.cxx:7219
TH1.cxx:7220
TH1.cxx:7221
TH1.cxx:7222
TH1.cxx:7223
TH1.cxx:7224
TH1.cxx:7225
TH1.cxx:7226
TH1.cxx:7227
TH1.cxx:7228
TH1.cxx:7229
TH1.cxx:7230
TH1.cxx:7231
TH1.cxx:7232
TH1.cxx:7233
TH1.cxx:7234
TH1.cxx:7235
TH1.cxx:7236
TH1.cxx:7237
TH1.cxx:7238
TH1.cxx:7239
TH1.cxx:7240
TH1.cxx:7241
TH1.cxx:7242
TH1.cxx:7243
TH1.cxx:7244
TH1.cxx:7245
TH1.cxx:7246
TH1.cxx:7247
TH1.cxx:7248
TH1.cxx:7249
TH1.cxx:7250
TH1.cxx:7251
TH1.cxx:7252
TH1.cxx:7253
TH1.cxx:7254
TH1.cxx:7255
TH1.cxx:7256
TH1.cxx:7257
TH1.cxx:7258
TH1.cxx:7259
TH1.cxx:7260
TH1.cxx:7261
TH1.cxx:7262
TH1.cxx:7263
TH1.cxx:7264
TH1.cxx:7265
TH1.cxx:7266
TH1.cxx:7267
TH1.cxx:7268
TH1.cxx:7269
TH1.cxx:7270
TH1.cxx:7271
TH1.cxx:7272
TH1.cxx:7273
TH1.cxx:7274
TH1.cxx:7275
TH1.cxx:7276
TH1.cxx:7277
TH1.cxx:7278
TH1.cxx:7279
TH1.cxx:7280
TH1.cxx:7281
TH1.cxx:7282
TH1.cxx:7283
TH1.cxx:7284
TH1.cxx:7285
TH1.cxx:7286
TH1.cxx:7287
TH1.cxx:7288
TH1.cxx:7289
TH1.cxx:7290
TH1.cxx:7291
TH1.cxx:7292
TH1.cxx:7293
TH1.cxx:7294
TH1.cxx:7295
TH1.cxx:7296
TH1.cxx:7297
TH1.cxx:7298
TH1.cxx:7299
TH1.cxx:7300
TH1.cxx:7301
TH1.cxx:7302
TH1.cxx:7303
TH1.cxx:7304
TH1.cxx:7305
TH1.cxx:7306
TH1.cxx:7307
TH1.cxx:7308
TH1.cxx:7309
TH1.cxx:7310
TH1.cxx:7311
TH1.cxx:7312
TH1.cxx:7313
TH1.cxx:7314
TH1.cxx:7315
TH1.cxx:7316
TH1.cxx:7317
TH1.cxx:7318
TH1.cxx:7319
TH1.cxx:7320
TH1.cxx:7321
TH1.cxx:7322
TH1.cxx:7323
TH1.cxx:7324
TH1.cxx:7325
TH1.cxx:7326
TH1.cxx:7327
TH1.cxx:7328
TH1.cxx:7329
TH1.cxx:7330
TH1.cxx:7331
TH1.cxx:7332
TH1.cxx:7333
TH1.cxx:7334
TH1.cxx:7335
TH1.cxx:7336
TH1.cxx:7337
TH1.cxx:7338
TH1.cxx:7339
TH1.cxx:7340
TH1.cxx:7341
TH1.cxx:7342
TH1.cxx:7343
TH1.cxx:7344
TH1.cxx:7345
TH1.cxx:7346
TH1.cxx:7347
TH1.cxx:7348
TH1.cxx:7349
TH1.cxx:7350
TH1.cxx:7351
TH1.cxx:7352
TH1.cxx:7353
TH1.cxx:7354
TH1.cxx:7355
TH1.cxx:7356
TH1.cxx:7357
TH1.cxx:7358
TH1.cxx:7359
TH1.cxx:7360
TH1.cxx:7361
TH1.cxx:7362
TH1.cxx:7363
TH1.cxx:7364
TH1.cxx:7365
TH1.cxx:7366
TH1.cxx:7367
TH1.cxx:7368
TH1.cxx:7369
TH1.cxx:7370
TH1.cxx:7371
TH1.cxx:7372
TH1.cxx:7373
TH1.cxx:7374
TH1.cxx:7375
TH1.cxx:7376
TH1.cxx:7377
TH1.cxx:7378
TH1.cxx:7379
TH1.cxx:7380
TH1.cxx:7381
TH1.cxx:7382
TH1.cxx:7383
TH1.cxx:7384
TH1.cxx:7385
TH1.cxx:7386
TH1.cxx:7387
TH1.cxx:7388
TH1.cxx:7389
TH1.cxx:7390
TH1.cxx:7391
TH1.cxx:7392
TH1.cxx:7393
TH1.cxx:7394
TH1.cxx:7395
TH1.cxx:7396
TH1.cxx:7397
TH1.cxx:7398
TH1.cxx:7399
TH1.cxx:7400
TH1.cxx:7401
TH1.cxx:7402
TH1.cxx:7403
TH1.cxx:7404
TH1.cxx:7405
TH1.cxx:7406
TH1.cxx:7407
TH1.cxx:7408
TH1.cxx:7409
TH1.cxx:7410
TH1.cxx:7411
TH1.cxx:7412
TH1.cxx:7413
TH1.cxx:7414
TH1.cxx:7415
TH1.cxx:7416
TH1.cxx:7417
TH1.cxx:7418
TH1.cxx:7419
TH1.cxx:7420
TH1.cxx:7421
TH1.cxx:7422
TH1.cxx:7423
TH1.cxx:7424
TH1.cxx:7425
TH1.cxx:7426
TH1.cxx:7427
TH1.cxx:7428
TH1.cxx:7429
TH1.cxx:7430
TH1.cxx:7431
TH1.cxx:7432
TH1.cxx:7433
TH1.cxx:7434
TH1.cxx:7435
TH1.cxx:7436
TH1.cxx:7437
TH1.cxx:7438
TH1.cxx:7439
TH1.cxx:7440
TH1.cxx:7441
TH1.cxx:7442
TH1.cxx:7443
TH1.cxx:7444
TH1.cxx:7445
TH1.cxx:7446
TH1.cxx:7447
TH1.cxx:7448
TH1.cxx:7449
TH1.cxx:7450
TH1.cxx:7451
TH1.cxx:7452
TH1.cxx:7453
TH1.cxx:7454
TH1.cxx:7455
TH1.cxx:7456
TH1.cxx:7457
TH1.cxx:7458
TH1.cxx:7459
TH1.cxx:7460
TH1.cxx:7461
TH1.cxx:7462
TH1.cxx:7463
TH1.cxx:7464
TH1.cxx:7465
TH1.cxx:7466
TH1.cxx:7467
TH1.cxx:7468
TH1.cxx:7469
TH1.cxx:7470
TH1.cxx:7471
TH1.cxx:7472
TH1.cxx:7473
TH1.cxx:7474
TH1.cxx:7475
TH1.cxx:7476
TH1.cxx:7477
TH1.cxx:7478
TH1.cxx:7479
TH1.cxx:7480
TH1.cxx:7481
TH1.cxx:7482
TH1.cxx:7483
TH1.cxx:7484
TH1.cxx:7485
TH1.cxx:7486
TH1.cxx:7487
TH1.cxx:7488
TH1.cxx:7489
TH1.cxx:7490
TH1.cxx:7491
TH1.cxx:7492
TH1.cxx:7493
TH1.cxx:7494
TH1.cxx:7495
TH1.cxx:7496
TH1.cxx:7497
TH1.cxx:7498
TH1.cxx:7499
TH1.cxx:7500
TH1.cxx:7501
TH1.cxx:7502
TH1.cxx:7503
TH1.cxx:7504
TH1.cxx:7505
TH1.cxx:7506
TH1.cxx:7507
TH1.cxx:7508
TH1.cxx:7509
TH1.cxx:7510
TH1.cxx:7511
TH1.cxx:7512
TH1.cxx:7513
TH1.cxx:7514
TH1.cxx:7515
TH1.cxx:7516
TH1.cxx:7517
TH1.cxx:7518
TH1.cxx:7519
TH1.cxx:7520
TH1.cxx:7521
TH1.cxx:7522
TH1.cxx:7523
TH1.cxx:7524
TH1.cxx:7525
TH1.cxx:7526
TH1.cxx:7527
TH1.cxx:7528
TH1.cxx:7529
TH1.cxx:7530
TH1.cxx:7531
TH1.cxx:7532
TH1.cxx:7533
TH1.cxx:7534
TH1.cxx:7535
TH1.cxx:7536
TH1.cxx:7537
TH1.cxx:7538
TH1.cxx:7539
TH1.cxx:7540
TH1.cxx:7541
TH1.cxx:7542
TH1.cxx:7543
TH1.cxx:7544
TH1.cxx:7545
TH1.cxx:7546
TH1.cxx:7547
TH1.cxx:7548
TH1.cxx:7549
TH1.cxx:7550
TH1.cxx:7551
TH1.cxx:7552
TH1.cxx:7553
TH1.cxx:7554
TH1.cxx:7555
TH1.cxx:7556
TH1.cxx:7557
TH1.cxx:7558
TH1.cxx:7559
TH1.cxx:7560
TH1.cxx:7561
TH1.cxx:7562
TH1.cxx:7563
TH1.cxx:7564
TH1.cxx:7565
TH1.cxx:7566
TH1.cxx:7567
TH1.cxx:7568
TH1.cxx:7569
TH1.cxx:7570
TH1.cxx:7571
TH1.cxx:7572
TH1.cxx:7573
TH1.cxx:7574
TH1.cxx:7575
TH1.cxx:7576
TH1.cxx:7577
TH1.cxx:7578
TH1.cxx:7579
TH1.cxx:7580
TH1.cxx:7581
TH1.cxx:7582
TH1.cxx:7583
TH1.cxx:7584
TH1.cxx:7585
TH1.cxx:7586
TH1.cxx:7587
TH1.cxx:7588
TH1.cxx:7589
TH1.cxx:7590
TH1.cxx:7591
TH1.cxx:7592
TH1.cxx:7593
TH1.cxx:7594
TH1.cxx:7595
TH1.cxx:7596
TH1.cxx:7597
TH1.cxx:7598
TH1.cxx:7599
TH1.cxx:7600
TH1.cxx:7601
TH1.cxx:7602
TH1.cxx:7603
TH1.cxx:7604
TH1.cxx:7605
TH1.cxx:7606
TH1.cxx:7607
TH1.cxx:7608
TH1.cxx:7609
TH1.cxx:7610
TH1.cxx:7611
TH1.cxx:7612
TH1.cxx:7613
TH1.cxx:7614
TH1.cxx:7615
TH1.cxx:7616
TH1.cxx:7617
TH1.cxx:7618
TH1.cxx:7619
TH1.cxx:7620
TH1.cxx:7621
TH1.cxx:7622
TH1.cxx:7623
TH1.cxx:7624
TH1.cxx:7625
TH1.cxx:7626
TH1.cxx:7627
TH1.cxx:7628
TH1.cxx:7629
TH1.cxx:7630
TH1.cxx:7631
TH1.cxx:7632
TH1.cxx:7633
TH1.cxx:7634
TH1.cxx:7635
TH1.cxx:7636
TH1.cxx:7637
TH1.cxx:7638
TH1.cxx:7639
TH1.cxx:7640
TH1.cxx:7641
TH1.cxx:7642
TH1.cxx:7643
TH1.cxx:7644
TH1.cxx:7645
TH1.cxx:7646
TH1.cxx:7647
TH1.cxx:7648
TH1.cxx:7649
TH1.cxx:7650
TH1.cxx:7651
TH1.cxx:7652
TH1.cxx:7653
TH1.cxx:7654
TH1.cxx:7655
TH1.cxx:7656
TH1.cxx:7657
TH1.cxx:7658
TH1.cxx:7659
TH1.cxx:7660
TH1.cxx:7661
TH1.cxx:7662
TH1.cxx:7663
TH1.cxx:7664
TH1.cxx:7665
TH1.cxx:7666
TH1.cxx:7667
TH1.cxx:7668
TH1.cxx:7669
TH1.cxx:7670
TH1.cxx:7671
TH1.cxx:7672
TH1.cxx:7673
TH1.cxx:7674
TH1.cxx:7675
TH1.cxx:7676
TH1.cxx:7677
TH1.cxx:7678
TH1.cxx:7679
TH1.cxx:7680
TH1.cxx:7681
TH1.cxx:7682
TH1.cxx:7683
TH1.cxx:7684
TH1.cxx:7685
TH1.cxx:7686
TH1.cxx:7687
TH1.cxx:7688
TH1.cxx:7689
TH1.cxx:7690
TH1.cxx:7691
TH1.cxx:7692
TH1.cxx:7693
TH1.cxx:7694
TH1.cxx:7695
TH1.cxx:7696
TH1.cxx:7697
TH1.cxx:7698
TH1.cxx:7699
TH1.cxx:7700
TH1.cxx:7701
TH1.cxx:7702
TH1.cxx:7703
TH1.cxx:7704
TH1.cxx:7705
TH1.cxx:7706
TH1.cxx:7707
TH1.cxx:7708
TH1.cxx:7709
TH1.cxx:7710
TH1.cxx:7711
TH1.cxx:7712
TH1.cxx:7713
TH1.cxx:7714
TH1.cxx:7715
TH1.cxx:7716
TH1.cxx:7717
TH1.cxx:7718
TH1.cxx:7719
TH1.cxx:7720
TH1.cxx:7721
TH1.cxx:7722
TH1.cxx:7723
TH1.cxx:7724
TH1.cxx:7725
TH1.cxx:7726
TH1.cxx:7727
TH1.cxx:7728
TH1.cxx:7729
TH1.cxx:7730
TH1.cxx:7731
TH1.cxx:7732
TH1.cxx:7733
TH1.cxx:7734
TH1.cxx:7735
TH1.cxx:7736
TH1.cxx:7737
TH1.cxx:7738
TH1.cxx:7739
TH1.cxx:7740
TH1.cxx:7741
TH1.cxx:7742
TH1.cxx:7743
TH1.cxx:7744
TH1.cxx:7745
TH1.cxx:7746
TH1.cxx:7747
TH1.cxx:7748
TH1.cxx:7749
TH1.cxx:7750
TH1.cxx:7751
TH1.cxx:7752
TH1.cxx:7753
TH1.cxx:7754
TH1.cxx:7755
TH1.cxx:7756
TH1.cxx:7757
TH1.cxx:7758
TH1.cxx:7759
TH1.cxx:7760
TH1.cxx:7761
TH1.cxx:7762
TH1.cxx:7763
TH1.cxx:7764
TH1.cxx:7765
TH1.cxx:7766
TH1.cxx:7767
TH1.cxx:7768
TH1.cxx:7769
TH1.cxx:7770
TH1.cxx:7771
TH1.cxx:7772
TH1.cxx:7773
TH1.cxx:7774
TH1.cxx:7775
TH1.cxx:7776
TH1.cxx:7777
TH1.cxx:7778
TH1.cxx:7779
TH1.cxx:7780
TH1.cxx:7781
TH1.cxx:7782
TH1.cxx:7783
TH1.cxx:7784
TH1.cxx:7785
TH1.cxx:7786
TH1.cxx:7787
TH1.cxx:7788
TH1.cxx:7789
TH1.cxx:7790
TH1.cxx:7791
TH1.cxx:7792
TH1.cxx:7793
TH1.cxx:7794
TH1.cxx:7795
TH1.cxx:7796
TH1.cxx:7797
TH1.cxx:7798
TH1.cxx:7799
TH1.cxx:7800
TH1.cxx:7801
TH1.cxx:7802
TH1.cxx:7803
TH1.cxx:7804
TH1.cxx:7805
TH1.cxx:7806
TH1.cxx:7807
TH1.cxx:7808
TH1.cxx:7809
TH1.cxx:7810
TH1.cxx:7811
TH1.cxx:7812
TH1.cxx:7813
TH1.cxx:7814
TH1.cxx:7815
TH1.cxx:7816
TH1.cxx:7817
TH1.cxx:7818
TH1.cxx:7819
TH1.cxx:7820
TH1.cxx:7821
TH1.cxx:7822
TH1.cxx:7823
TH1.cxx:7824
TH1.cxx:7825
TH1.cxx:7826
TH1.cxx:7827
TH1.cxx:7828
TH1.cxx:7829
TH1.cxx:7830
TH1.cxx:7831
TH1.cxx:7832
TH1.cxx:7833
TH1.cxx:7834
TH1.cxx:7835
TH1.cxx:7836
TH1.cxx:7837
TH1.cxx:7838
TH1.cxx:7839
TH1.cxx:7840
TH1.cxx:7841
TH1.cxx:7842
TH1.cxx:7843
TH1.cxx:7844
TH1.cxx:7845
TH1.cxx:7846
TH1.cxx:7847
TH1.cxx:7848
TH1.cxx:7849
TH1.cxx:7850
TH1.cxx:7851
TH1.cxx:7852
TH1.cxx:7853
TH1.cxx:7854
TH1.cxx:7855
TH1.cxx:7856
TH1.cxx:7857
TH1.cxx:7858
TH1.cxx:7859
TH1.cxx:7860
TH1.cxx:7861
TH1.cxx:7862
TH1.cxx:7863
TH1.cxx:7864
TH1.cxx:7865
TH1.cxx:7866
TH1.cxx:7867
TH1.cxx:7868
TH1.cxx:7869
TH1.cxx:7870
TH1.cxx:7871
TH1.cxx:7872
TH1.cxx:7873
TH1.cxx:7874
TH1.cxx:7875
TH1.cxx:7876
TH1.cxx:7877
TH1.cxx:7878
TH1.cxx:7879
TH1.cxx:7880
TH1.cxx:7881
TH1.cxx:7882
TH1.cxx:7883
TH1.cxx:7884
TH1.cxx:7885
TH1.cxx:7886
TH1.cxx:7887
TH1.cxx:7888
TH1.cxx:7889
TH1.cxx:7890
TH1.cxx:7891
TH1.cxx:7892
TH1.cxx:7893
TH1.cxx:7894
TH1.cxx:7895
TH1.cxx:7896
TH1.cxx:7897
TH1.cxx:7898
TH1.cxx:7899
TH1.cxx:7900
TH1.cxx:7901
TH1.cxx:7902
TH1.cxx:7903
TH1.cxx:7904
TH1.cxx:7905
TH1.cxx:7906
TH1.cxx:7907
TH1.cxx:7908
TH1.cxx:7909
TH1.cxx:7910
TH1.cxx:7911
TH1.cxx:7912
TH1.cxx:7913
TH1.cxx:7914
TH1.cxx:7915
TH1.cxx:7916
TH1.cxx:7917
TH1.cxx:7918
TH1.cxx:7919
TH1.cxx:7920
TH1.cxx:7921
TH1.cxx:7922
TH1.cxx:7923
TH1.cxx:7924
TH1.cxx:7925
TH1.cxx:7926
TH1.cxx:7927
TH1.cxx:7928
TH1.cxx:7929
TH1.cxx:7930
TH1.cxx:7931
TH1.cxx:7932
TH1.cxx:7933
TH1.cxx:7934
TH1.cxx:7935
TH1.cxx:7936
TH1.cxx:7937
TH1.cxx:7938
TH1.cxx:7939
TH1.cxx:7940
TH1.cxx:7941
TH1.cxx:7942
TH1.cxx:7943
TH1.cxx:7944
TH1.cxx:7945
TH1.cxx:7946
TH1.cxx:7947
TH1.cxx:7948
TH1.cxx:7949
TH1.cxx:7950
TH1.cxx:7951
TH1.cxx:7952
TH1.cxx:7953
TH1.cxx:7954
TH1.cxx:7955
TH1.cxx:7956
TH1.cxx:7957
TH1.cxx:7958
TH1.cxx:7959
TH1.cxx:7960
TH1.cxx:7961
TH1.cxx:7962
TH1.cxx:7963
TH1.cxx:7964
TH1.cxx:7965
TH1.cxx:7966
TH1.cxx:7967
TH1.cxx:7968
TH1.cxx:7969
TH1.cxx:7970
TH1.cxx:7971
TH1.cxx:7972
TH1.cxx:7973
TH1.cxx:7974
TH1.cxx:7975
TH1.cxx:7976
TH1.cxx:7977
TH1.cxx:7978
TH1.cxx:7979
TH1.cxx:7980
TH1.cxx:7981
TH1.cxx:7982
TH1.cxx:7983
TH1.cxx:7984
TH1.cxx:7985
TH1.cxx:7986
TH1.cxx:7987
TH1.cxx:7988
TH1.cxx:7989
TH1.cxx:7990
TH1.cxx:7991
TH1.cxx:7992
TH1.cxx:7993
TH1.cxx:7994
TH1.cxx:7995
TH1.cxx:7996
TH1.cxx:7997
TH1.cxx:7998
TH1.cxx:7999
TH1.cxx:8000
TH1.cxx:8001
TH1.cxx:8002
TH1.cxx:8003
TH1.cxx:8004
TH1.cxx:8005
TH1.cxx:8006
TH1.cxx:8007
TH1.cxx:8008
TH1.cxx:8009
TH1.cxx:8010
TH1.cxx:8011
TH1.cxx:8012
TH1.cxx:8013
TH1.cxx:8014
TH1.cxx:8015
TH1.cxx:8016
TH1.cxx:8017
TH1.cxx:8018
TH1.cxx:8019
TH1.cxx:8020
TH1.cxx:8021
TH1.cxx:8022
TH1.cxx:8023
TH1.cxx:8024
TH1.cxx:8025
TH1.cxx:8026
TH1.cxx:8027
TH1.cxx:8028
TH1.cxx:8029
TH1.cxx:8030
TH1.cxx:8031
TH1.cxx:8032
TH1.cxx:8033
TH1.cxx:8034
TH1.cxx:8035
TH1.cxx:8036
TH1.cxx:8037
TH1.cxx:8038
TH1.cxx:8039
TH1.cxx:8040
TH1.cxx:8041
TH1.cxx:8042
TH1.cxx:8043
TH1.cxx:8044
TH1.cxx:8045
TH1.cxx:8046
TH1.cxx:8047
TH1.cxx:8048
TH1.cxx:8049
TH1.cxx:8050
TH1.cxx:8051
TH1.cxx:8052
TH1.cxx:8053
TH1.cxx:8054
TH1.cxx:8055
TH1.cxx:8056
TH1.cxx:8057
TH1.cxx:8058
TH1.cxx:8059
TH1.cxx:8060
TH1.cxx:8061
TH1.cxx:8062
TH1.cxx:8063
TH1.cxx:8064
TH1.cxx:8065
TH1.cxx:8066
TH1.cxx:8067
TH1.cxx:8068
TH1.cxx:8069
TH1.cxx:8070
TH1.cxx:8071
TH1.cxx:8072
TH1.cxx:8073
TH1.cxx:8074
TH1.cxx:8075
TH1.cxx:8076
TH1.cxx:8077
TH1.cxx:8078
TH1.cxx:8079
TH1.cxx:8080
TH1.cxx:8081
TH1.cxx:8082
TH1.cxx:8083
TH1.cxx:8084
TH1.cxx:8085
TH1.cxx:8086
TH1.cxx:8087
TH1.cxx:8088
TH1.cxx:8089
TH1.cxx:8090
TH1.cxx:8091
TH1.cxx:8092
TH1.cxx:8093
TH1.cxx:8094
TH1.cxx:8095
TH1.cxx:8096
TH1.cxx:8097
TH1.cxx:8098
TH1.cxx:8099
TH1.cxx:8100
TH1.cxx:8101
TH1.cxx:8102
TH1.cxx:8103
TH1.cxx:8104
TH1.cxx:8105
TH1.cxx:8106
TH1.cxx:8107
TH1.cxx:8108
TH1.cxx:8109
TH1.cxx:8110
TH1.cxx:8111
TH1.cxx:8112
TH1.cxx:8113
TH1.cxx:8114
TH1.cxx:8115
TH1.cxx:8116
TH1.cxx:8117
TH1.cxx:8118
TH1.cxx:8119
TH1.cxx:8120
TH1.cxx:8121
TH1.cxx:8122
TH1.cxx:8123
TH1.cxx:8124
TH1.cxx:8125
TH1.cxx:8126
TH1.cxx:8127
TH1.cxx:8128
TH1.cxx:8129
TH1.cxx:8130
TH1.cxx:8131
TH1.cxx:8132
TH1.cxx:8133
TH1.cxx:8134
TH1.cxx:8135
TH1.cxx:8136
TH1.cxx:8137
TH1.cxx:8138
TH1.cxx:8139
TH1.cxx:8140
TH1.cxx:8141
TH1.cxx:8142
TH1.cxx:8143
TH1.cxx:8144
TH1.cxx:8145
TH1.cxx:8146
TH1.cxx:8147
TH1.cxx:8148
TH1.cxx:8149
TH1.cxx:8150
TH1.cxx:8151
TH1.cxx:8152
TH1.cxx:8153
TH1.cxx:8154
TH1.cxx:8155
TH1.cxx:8156
TH1.cxx:8157
TH1.cxx:8158
TH1.cxx:8159
TH1.cxx:8160
TH1.cxx:8161
TH1.cxx:8162
TH1.cxx:8163
TH1.cxx:8164
TH1.cxx:8165
TH1.cxx:8166
TH1.cxx:8167
TH1.cxx:8168
TH1.cxx:8169
TH1.cxx:8170
TH1.cxx:8171
TH1.cxx:8172
TH1.cxx:8173
TH1.cxx:8174
TH1.cxx:8175
TH1.cxx:8176
TH1.cxx:8177
TH1.cxx:8178
TH1.cxx:8179
TH1.cxx:8180
TH1.cxx:8181
TH1.cxx:8182
TH1.cxx:8183
TH1.cxx:8184
TH1.cxx:8185
TH1.cxx:8186
TH1.cxx:8187
TH1.cxx:8188
TH1.cxx:8189
TH1.cxx:8190
TH1.cxx:8191
TH1.cxx:8192
TH1.cxx:8193
TH1.cxx:8194
TH1.cxx:8195
TH1.cxx:8196
TH1.cxx:8197
TH1.cxx:8198
TH1.cxx:8199
TH1.cxx:8200
TH1.cxx:8201
TH1.cxx:8202
TH1.cxx:8203
TH1.cxx:8204
TH1.cxx:8205
TH1.cxx:8206
TH1.cxx:8207
TH1.cxx:8208
TH1.cxx:8209
TH1.cxx:8210
TH1.cxx:8211
TH1.cxx:8212
TH1.cxx:8213
TH1.cxx:8214
TH1.cxx:8215
TH1.cxx:8216
TH1.cxx:8217
TH1.cxx:8218
TH1.cxx:8219
TH1.cxx:8220
TH1.cxx:8221
TH1.cxx:8222
TH1.cxx:8223
TH1.cxx:8224
TH1.cxx:8225
TH1.cxx:8226
TH1.cxx:8227
TH1.cxx:8228
TH1.cxx:8229
TH1.cxx:8230
TH1.cxx:8231
TH1.cxx:8232
TH1.cxx:8233
TH1.cxx:8234
TH1.cxx:8235
TH1.cxx:8236
TH1.cxx:8237
TH1.cxx:8238
TH1.cxx:8239
TH1.cxx:8240
TH1.cxx:8241
TH1.cxx:8242
TH1.cxx:8243
TH1.cxx:8244
TH1.cxx:8245
TH1.cxx:8246
TH1.cxx:8247
TH1.cxx:8248
TH1.cxx:8249
TH1.cxx:8250
TH1.cxx:8251
TH1.cxx:8252
TH1.cxx:8253
TH1.cxx:8254
TH1.cxx:8255
TH1.cxx:8256
TH1.cxx:8257
TH1.cxx:8258
TH1.cxx:8259
TH1.cxx:8260
TH1.cxx:8261
TH1.cxx:8262
TH1.cxx:8263
TH1.cxx:8264
TH1.cxx:8265
TH1.cxx:8266
TH1.cxx:8267
TH1.cxx:8268
TH1.cxx:8269
TH1.cxx:8270
TH1.cxx:8271
TH1.cxx:8272
TH1.cxx:8273
TH1.cxx:8274
TH1.cxx:8275
TH1.cxx:8276
TH1.cxx:8277
TH1.cxx:8278
TH1.cxx:8279
TH1.cxx:8280
TH1.cxx:8281
TH1.cxx:8282
TH1.cxx:8283
TH1.cxx:8284
TH1.cxx:8285
TH1.cxx:8286
TH1.cxx:8287
TH1.cxx:8288
TH1.cxx:8289
TH1.cxx:8290
TH1.cxx:8291
TH1.cxx:8292
TH1.cxx:8293
TH1.cxx:8294
TH1.cxx:8295
TH1.cxx:8296
TH1.cxx:8297
TH1.cxx:8298
TH1.cxx:8299
TH1.cxx:8300
TH1.cxx:8301
TH1.cxx:8302
TH1.cxx:8303
TH1.cxx:8304
TH1.cxx:8305
TH1.cxx:8306
TH1.cxx:8307
TH1.cxx:8308
TH1.cxx:8309
TH1.cxx:8310
TH1.cxx:8311
TH1.cxx:8312
TH1.cxx:8313
TH1.cxx:8314
TH1.cxx:8315
TH1.cxx:8316
TH1.cxx:8317
TH1.cxx:8318
TH1.cxx:8319
TH1.cxx:8320
TH1.cxx:8321
TH1.cxx:8322
TH1.cxx:8323
TH1.cxx:8324
TH1.cxx:8325
TH1.cxx:8326
TH1.cxx:8327
TH1.cxx:8328
TH1.cxx:8329
TH1.cxx:8330
TH1.cxx:8331
TH1.cxx:8332
TH1.cxx:8333
TH1.cxx:8334
TH1.cxx:8335
TH1.cxx:8336
TH1.cxx:8337
TH1.cxx:8338
TH1.cxx:8339
TH1.cxx:8340
TH1.cxx:8341
TH1.cxx:8342
TH1.cxx:8343
TH1.cxx:8344
TH1.cxx:8345
TH1.cxx:8346
TH1.cxx:8347
TH1.cxx:8348
TH1.cxx:8349
TH1.cxx:8350
TH1.cxx:8351
TH1.cxx:8352
TH1.cxx:8353
TH1.cxx:8354
TH1.cxx:8355
TH1.cxx:8356
TH1.cxx:8357
TH1.cxx:8358
TH1.cxx:8359
TH1.cxx:8360
TH1.cxx:8361
TH1.cxx:8362
TH1.cxx:8363
TH1.cxx:8364
TH1.cxx:8365
TH1.cxx:8366
TH1.cxx:8367
TH1.cxx:8368
TH1.cxx:8369
TH1.cxx:8370
TH1.cxx:8371
TH1.cxx:8372
TH1.cxx:8373
TH1.cxx:8374
TH1.cxx:8375
TH1.cxx:8376
TH1.cxx:8377
TH1.cxx:8378
TH1.cxx:8379
TH1.cxx:8380
TH1.cxx:8381
TH1.cxx:8382
TH1.cxx:8383
TH1.cxx:8384
TH1.cxx:8385
TH1.cxx:8386
TH1.cxx:8387
TH1.cxx:8388
TH1.cxx:8389
TH1.cxx:8390
TH1.cxx:8391
TH1.cxx:8392
TH1.cxx:8393
TH1.cxx:8394
TH1.cxx:8395
TH1.cxx:8396
TH1.cxx:8397
TH1.cxx:8398
TH1.cxx:8399
TH1.cxx:8400
TH1.cxx:8401
TH1.cxx:8402
TH1.cxx:8403
TH1.cxx:8404
TH1.cxx:8405
TH1.cxx:8406
TH1.cxx:8407
TH1.cxx:8408
TH1.cxx:8409
TH1.cxx:8410
TH1.cxx:8411
TH1.cxx:8412
TH1.cxx:8413
TH1.cxx:8414
TH1.cxx:8415
TH1.cxx:8416
TH1.cxx:8417
TH1.cxx:8418
TH1.cxx:8419
TH1.cxx:8420
TH1.cxx:8421
TH1.cxx:8422
TH1.cxx:8423
TH1.cxx:8424
TH1.cxx:8425
TH1.cxx:8426
TH1.cxx:8427
TH1.cxx:8428
TH1.cxx:8429
TH1.cxx:8430
TH1.cxx:8431
TH1.cxx:8432
TH1.cxx:8433
TH1.cxx:8434
TH1.cxx:8435
TH1.cxx:8436
TH1.cxx:8437
TH1.cxx:8438
TH1.cxx:8439
TH1.cxx:8440
TH1.cxx:8441
TH1.cxx:8442
TH1.cxx:8443
TH1.cxx:8444
TH1.cxx:8445
TH1.cxx:8446
TH1.cxx:8447
TH1.cxx:8448
TH1.cxx:8449
TH1.cxx:8450
TH1.cxx:8451
TH1.cxx:8452
TH1.cxx:8453
TH1.cxx:8454
TH1.cxx:8455
TH1.cxx:8456
TH1.cxx:8457
TH1.cxx:8458
TH1.cxx:8459
TH1.cxx:8460
TH1.cxx:8461
TH1.cxx:8462
TH1.cxx:8463
TH1.cxx:8464
TH1.cxx:8465
TH1.cxx:8466
TH1.cxx:8467
TH1.cxx:8468
TH1.cxx:8469
TH1.cxx:8470
TH1.cxx:8471
TH1.cxx:8472
TH1.cxx:8473
TH1.cxx:8474
TH1.cxx:8475
TH1.cxx:8476
TH1.cxx:8477
TH1.cxx:8478
TH1.cxx:8479
TH1.cxx:8480
TH1.cxx:8481
TH1.cxx:8482
TH1.cxx:8483
TH1.cxx:8484
TH1.cxx:8485
TH1.cxx:8486
TH1.cxx:8487
TH1.cxx:8488
TH1.cxx:8489
TH1.cxx:8490
TH1.cxx:8491
TH1.cxx:8492
TH1.cxx:8493
TH1.cxx:8494
TH1.cxx:8495
TH1.cxx:8496
TH1.cxx:8497
TH1.cxx:8498
TH1.cxx:8499
TH1.cxx:8500
TH1.cxx:8501
TH1.cxx:8502
TH1.cxx:8503
TH1.cxx:8504
TH1.cxx:8505
TH1.cxx:8506
TH1.cxx:8507
TH1.cxx:8508
TH1.cxx:8509
TH1.cxx:8510
TH1.cxx:8511
TH1.cxx:8512
TH1.cxx:8513
TH1.cxx:8514
TH1.cxx:8515
TH1.cxx:8516
TH1.cxx:8517
TH1.cxx:8518
TH1.cxx:8519
TH1.cxx:8520
TH1.cxx:8521
TH1.cxx:8522
TH1.cxx:8523
TH1.cxx:8524
TH1.cxx:8525
TH1.cxx:8526
TH1.cxx:8527
TH1.cxx:8528
TH1.cxx:8529
TH1.cxx:8530
TH1.cxx:8531
TH1.cxx:8532
TH1.cxx:8533
TH1.cxx:8534
TH1.cxx:8535
TH1.cxx:8536
TH1.cxx:8537
TH1.cxx:8538
TH1.cxx:8539
TH1.cxx:8540
TH1.cxx:8541
TH1.cxx:8542
TH1.cxx:8543
TH1.cxx:8544
TH1.cxx:8545
TH1.cxx:8546
TH1.cxx:8547
TH1.cxx:8548
TH1.cxx:8549
TH1.cxx:8550
TH1.cxx:8551
TH1.cxx:8552
TH1.cxx:8553
TH1.cxx:8554
TH1.cxx:8555
TH1.cxx:8556
TH1.cxx:8557
TH1.cxx:8558
TH1.cxx:8559
TH1.cxx:8560
TH1.cxx:8561
TH1.cxx:8562
TH1.cxx:8563
TH1.cxx:8564
TH1.cxx:8565
TH1.cxx:8566
TH1.cxx:8567
TH1.cxx:8568
TH1.cxx:8569
TH1.cxx:8570
TH1.cxx:8571
TH1.cxx:8572
TH1.cxx:8573
TH1.cxx:8574
TH1.cxx:8575
TH1.cxx:8576
TH1.cxx:8577
TH1.cxx:8578
TH1.cxx:8579
TH1.cxx:8580
TH1.cxx:8581
TH1.cxx:8582
TH1.cxx:8583
TH1.cxx:8584
TH1.cxx:8585
TH1.cxx:8586
TH1.cxx:8587
TH1.cxx:8588
TH1.cxx:8589
TH1.cxx:8590
TH1.cxx:8591
TH1.cxx:8592
TH1.cxx:8593
TH1.cxx:8594
TH1.cxx:8595
TH1.cxx:8596
TH1.cxx:8597
TH1.cxx:8598
TH1.cxx:8599
TH1.cxx:8600
TH1.cxx:8601
TH1.cxx:8602
TH1.cxx:8603
TH1.cxx:8604
TH1.cxx:8605
TH1.cxx:8606
TH1.cxx:8607
TH1.cxx:8608
TH1.cxx:8609
TH1.cxx:8610
TH1.cxx:8611
TH1.cxx:8612
TH1.cxx:8613
TH1.cxx:8614
TH1.cxx:8615
TH1.cxx:8616
TH1.cxx:8617
TH1.cxx:8618
TH1.cxx:8619
TH1.cxx:8620
TH1.cxx:8621
TH1.cxx:8622
TH1.cxx:8623
TH1.cxx:8624
TH1.cxx:8625
TH1.cxx:8626
TH1.cxx:8627
TH1.cxx:8628
TH1.cxx:8629
TH1.cxx:8630
TH1.cxx:8631
TH1.cxx:8632
TH1.cxx:8633
TH1.cxx:8634
TH1.cxx:8635
TH1.cxx:8636
TH1.cxx:8637
TH1.cxx:8638
TH1.cxx:8639
TH1.cxx:8640
TH1.cxx:8641
TH1.cxx:8642
TH1.cxx:8643
TH1.cxx:8644
TH1.cxx:8645
TH1.cxx:8646
TH1.cxx:8647
TH1.cxx:8648
TH1.cxx:8649
TH1.cxx:8650
TH1.cxx:8651
TH1.cxx:8652
TH1.cxx:8653
TH1.cxx:8654
TH1.cxx:8655
TH1.cxx:8656
TH1.cxx:8657
TH1.cxx:8658
TH1.cxx:8659
TH1.cxx:8660
TH1.cxx:8661
TH1.cxx:8662
TH1.cxx:8663
TH1.cxx:8664
TH1.cxx:8665
TH1.cxx:8666
TH1.cxx:8667
TH1.cxx:8668
TH1.cxx:8669
TH1.cxx:8670
TH1.cxx:8671
TH1.cxx:8672
TH1.cxx:8673
TH1.cxx:8674
TH1.cxx:8675
TH1.cxx:8676
TH1.cxx:8677
TH1.cxx:8678
TH1.cxx:8679
TH1.cxx:8680
TH1.cxx:8681
TH1.cxx:8682
TH1.cxx:8683
TH1.cxx:8684
TH1.cxx:8685
TH1.cxx:8686
TH1.cxx:8687
TH1.cxx:8688
TH1.cxx:8689
TH1.cxx:8690
TH1.cxx:8691
TH1.cxx:8692
TH1.cxx:8693
TH1.cxx:8694
TH1.cxx:8695
TH1.cxx:8696
TH1.cxx:8697
TH1.cxx:8698
TH1.cxx:8699
TH1.cxx:8700
TH1.cxx:8701
TH1.cxx:8702
TH1.cxx:8703
TH1.cxx:8704
TH1.cxx:8705
TH1.cxx:8706
TH1.cxx:8707
TH1.cxx:8708
TH1.cxx:8709
TH1.cxx:8710
TH1.cxx:8711
TH1.cxx:8712
TH1.cxx:8713
TH1.cxx:8714
TH1.cxx:8715
TH1.cxx:8716
TH1.cxx:8717
TH1.cxx:8718
TH1.cxx:8719
TH1.cxx:8720
TH1.cxx:8721
TH1.cxx:8722
TH1.cxx:8723
TH1.cxx:8724
TH1.cxx:8725
TH1.cxx:8726
TH1.cxx:8727
TH1.cxx:8728
TH1.cxx:8729
TH1.cxx:8730
TH1.cxx:8731
TH1.cxx:8732
TH1.cxx:8733
TH1.cxx:8734
TH1.cxx:8735
TH1.cxx:8736
TH1.cxx:8737
TH1.cxx:8738
TH1.cxx:8739
TH1.cxx:8740
TH1.cxx:8741
TH1.cxx:8742
TH1.cxx:8743
TH1.cxx:8744
TH1.cxx:8745
TH1.cxx:8746
TH1.cxx:8747
TH1.cxx:8748
TH1.cxx:8749
TH1.cxx:8750
TH1.cxx:8751
TH1.cxx:8752
TH1.cxx:8753
TH1.cxx:8754
TH1.cxx:8755
TH1.cxx:8756
TH1.cxx:8757
TH1.cxx:8758
TH1.cxx:8759
TH1.cxx:8760
TH1.cxx:8761
TH1.cxx:8762
TH1.cxx:8763
TH1.cxx:8764
TH1.cxx:8765
TH1.cxx:8766
TH1.cxx:8767
TH1.cxx:8768
TH1.cxx:8769
TH1.cxx:8770
TH1.cxx:8771
TH1.cxx:8772
TH1.cxx:8773
TH1.cxx:8774
TH1.cxx:8775
TH1.cxx:8776
TH1.cxx:8777
TH1.cxx:8778
TH1.cxx:8779
TH1.cxx:8780
TH1.cxx:8781
TH1.cxx:8782
TH1.cxx:8783
TH1.cxx:8784
TH1.cxx:8785
TH1.cxx:8786
TH1.cxx:8787
TH1.cxx:8788
TH1.cxx:8789
TH1.cxx:8790
TH1.cxx:8791
TH1.cxx:8792
TH1.cxx:8793
TH1.cxx:8794
TH1.cxx:8795
TH1.cxx:8796
TH1.cxx:8797
TH1.cxx:8798
TH1.cxx:8799
TH1.cxx:8800
TH1.cxx:8801
TH1.cxx:8802
TH1.cxx:8803
TH1.cxx:8804
TH1.cxx:8805
TH1.cxx:8806
TH1.cxx:8807
TH1.cxx:8808
TH1.cxx:8809
TH1.cxx:8810
TH1.cxx:8811
TH1.cxx:8812
TH1.cxx:8813
TH1.cxx:8814
TH1.cxx:8815
TH1.cxx:8816
TH1.cxx:8817
TH1.cxx:8818
TH1.cxx:8819
TH1.cxx:8820
TH1.cxx:8821
TH1.cxx:8822
TH1.cxx:8823
TH1.cxx:8824
TH1.cxx:8825
TH1.cxx:8826
TH1.cxx:8827
TH1.cxx:8828
TH1.cxx:8829
TH1.cxx:8830
TH1.cxx:8831
TH1.cxx:8832
TH1.cxx:8833
TH1.cxx:8834
TH1.cxx:8835
TH1.cxx:8836
TH1.cxx:8837
TH1.cxx:8838
TH1.cxx:8839
TH1.cxx:8840
TH1.cxx:8841
TH1.cxx:8842
TH1.cxx:8843
TH1.cxx:8844
TH1.cxx:8845
TH1.cxx:8846
TH1.cxx:8847
TH1.cxx:8848
TH1.cxx:8849
TH1.cxx:8850
TH1.cxx:8851
TH1.cxx:8852
TH1.cxx:8853
TH1.cxx:8854
TH1.cxx:8855
TH1.cxx:8856
TH1.cxx:8857
TH1.cxx:8858
TH1.cxx:8859
TH1.cxx:8860
TH1.cxx:8861
TH1.cxx:8862
TH1.cxx:8863
TH1.cxx:8864
TH1.cxx:8865
TH1.cxx:8866
TH1.cxx:8867
TH1.cxx:8868
TH1.cxx:8869
TH1.cxx:8870
TH1.cxx:8871
TH1.cxx:8872
TH1.cxx:8873
TH1.cxx:8874
TH1.cxx:8875
TH1.cxx:8876
TH1.cxx:8877
TH1.cxx:8878
TH1.cxx:8879
TH1.cxx:8880
TH1.cxx:8881
TH1.cxx:8882
TH1.cxx:8883
TH1.cxx:8884
TH1.cxx:8885
TH1.cxx:8886
TH1.cxx:8887
TH1.cxx:8888
TH1.cxx:8889
TH1.cxx:8890
TH1.cxx:8891
TH1.cxx:8892
TH1.cxx:8893
TH1.cxx:8894
TH1.cxx:8895
TH1.cxx:8896
TH1.cxx:8897
TH1.cxx:8898
TH1.cxx:8899
TH1.cxx:8900
TH1.cxx:8901
TH1.cxx:8902
TH1.cxx:8903
TH1.cxx:8904
TH1.cxx:8905
TH1.cxx:8906
TH1.cxx:8907
TH1.cxx:8908
TH1.cxx:8909
TH1.cxx:8910
TH1.cxx:8911
TH1.cxx:8912
TH1.cxx:8913
TH1.cxx:8914
TH1.cxx:8915
TH1.cxx:8916
TH1.cxx:8917
TH1.cxx:8918
TH1.cxx:8919
TH1.cxx:8920
TH1.cxx:8921
TH1.cxx:8922
TH1.cxx:8923
TH1.cxx:8924
TH1.cxx:8925
TH1.cxx:8926
TH1.cxx:8927
TH1.cxx:8928
TH1.cxx:8929
TH1.cxx:8930
TH1.cxx:8931
TH1.cxx:8932
TH1.cxx:8933
TH1.cxx:8934
TH1.cxx:8935
TH1.cxx:8936
TH1.cxx:8937
TH1.cxx:8938
TH1.cxx:8939
TH1.cxx:8940
TH1.cxx:8941
TH1.cxx:8942
TH1.cxx:8943
TH1.cxx:8944
TH1.cxx:8945
TH1.cxx:8946
TH1.cxx:8947
TH1.cxx:8948
TH1.cxx:8949
TH1.cxx:8950
TH1.cxx:8951
TH1.cxx:8952
TH1.cxx:8953
TH1.cxx:8954
TH1.cxx:8955
TH1.cxx:8956
TH1.cxx:8957
TH1.cxx:8958
TH1.cxx:8959
TH1.cxx:8960
TH1.cxx:8961
TH1.cxx:8962
TH1.cxx:8963
TH1.cxx:8964
TH1.cxx:8965
TH1.cxx:8966
TH1.cxx:8967
TH1.cxx:8968
TH1.cxx:8969
TH1.cxx:8970
TH1.cxx:8971
TH1.cxx:8972
TH1.cxx:8973
TH1.cxx:8974
TH1.cxx:8975
TH1.cxx:8976
TH1.cxx:8977
TH1.cxx:8978
TH1.cxx:8979
TH1.cxx:8980
TH1.cxx:8981
TH1.cxx:8982
TH1.cxx:8983
TH1.cxx:8984
TH1.cxx:8985
TH1.cxx:8986
TH1.cxx:8987
TH1.cxx:8988
TH1.cxx:8989
TH1.cxx:8990
TH1.cxx:8991
TH1.cxx:8992
TH1.cxx:8993
TH1.cxx:8994
TH1.cxx:8995
TH1.cxx:8996
TH1.cxx:8997
TH1.cxx:8998
TH1.cxx:8999
TH1.cxx:9000
TH1.cxx:9001
TH1.cxx:9002
TH1.cxx:9003
TH1.cxx:9004
TH1.cxx:9005
TH1.cxx:9006
TH1.cxx:9007
TH1.cxx:9008
TH1.cxx:9009
TH1.cxx:9010
TH1.cxx:9011
TH1.cxx:9012
TH1.cxx:9013
TH1.cxx:9014
TH1.cxx:9015
TH1.cxx:9016
TH1.cxx:9017
TH1.cxx:9018
TH1.cxx:9019
TH1.cxx:9020
TH1.cxx:9021
TH1.cxx:9022
TH1.cxx:9023
TH1.cxx:9024
TH1.cxx:9025
TH1.cxx:9026
TH1.cxx:9027
TH1.cxx:9028
TH1.cxx:9029
TH1.cxx:9030
TH1.cxx:9031
TH1.cxx:9032
TH1.cxx:9033
TH1.cxx:9034
TH1.cxx:9035
TH1.cxx:9036
TH1.cxx:9037
TH1.cxx:9038
TH1.cxx:9039
TH1.cxx:9040
TH1.cxx:9041
TH1.cxx:9042
TH1.cxx:9043
TH1.cxx:9044
TH1.cxx:9045
TH1.cxx:9046
TH1.cxx:9047
TH1.cxx:9048
TH1.cxx:9049
TH1.cxx:9050
TH1.cxx:9051
TH1.cxx:9052
TH1.cxx:9053
TH1.cxx:9054
TH1.cxx:9055
TH1.cxx:9056
TH1.cxx:9057
TH1.cxx:9058
TH1.cxx:9059
TH1.cxx:9060
TH1.cxx:9061
TH1.cxx:9062
TH1.cxx:9063
TH1.cxx:9064
TH1.cxx:9065
TH1.cxx:9066
TH1.cxx:9067
TH1.cxx:9068
TH1.cxx:9069
TH1.cxx:9070
TH1.cxx:9071
TH1.cxx:9072
TH1.cxx:9073
TH1.cxx:9074
TH1.cxx:9075
TH1.cxx:9076
TH1.cxx:9077
TH1.cxx:9078
TH1.cxx:9079
TH1.cxx:9080
TH1.cxx:9081
TH1.cxx:9082
TH1.cxx:9083
TH1.cxx:9084
TH1.cxx:9085
TH1.cxx:9086
TH1.cxx:9087
TH1.cxx:9088
TH1.cxx:9089
TH1.cxx:9090
TH1.cxx:9091
TH1.cxx:9092
TH1.cxx:9093
TH1.cxx:9094
TH1.cxx:9095
TH1.cxx:9096
TH1.cxx:9097
TH1.cxx:9098
TH1.cxx:9099
TH1.cxx:9100
TH1.cxx:9101
TH1.cxx:9102
TH1.cxx:9103
TH1.cxx:9104
TH1.cxx:9105
TH1.cxx:9106
TH1.cxx:9107
TH1.cxx:9108
TH1.cxx:9109
TH1.cxx:9110
TH1.cxx:9111
TH1.cxx:9112
TH1.cxx:9113
TH1.cxx:9114
TH1.cxx:9115
TH1.cxx:9116
TH1.cxx:9117
TH1.cxx:9118
TH1.cxx:9119
TH1.cxx:9120
TH1.cxx:9121
TH1.cxx:9122
TH1.cxx:9123
TH1.cxx:9124
TH1.cxx:9125
TH1.cxx:9126
TH1.cxx:9127
TH1.cxx:9128
TH1.cxx:9129
TH1.cxx:9130
TH1.cxx:9131
TH1.cxx:9132
TH1.cxx:9133
TH1.cxx:9134
TH1.cxx:9135
TH1.cxx:9136
TH1.cxx:9137
TH1.cxx:9138
TH1.cxx:9139
TH1.cxx:9140
TH1.cxx:9141
TH1.cxx:9142
TH1.cxx:9143
TH1.cxx:9144
TH1.cxx:9145
TH1.cxx:9146
TH1.cxx:9147
TH1.cxx:9148
TH1.cxx:9149
TH1.cxx:9150
TH1.cxx:9151
TH1.cxx:9152
TH1.cxx:9153
TH1.cxx:9154
TH1.cxx:9155
TH1.cxx:9156
TH1.cxx:9157
TH1.cxx:9158
TH1.cxx:9159
TH1.cxx:9160
TH1.cxx:9161
TH1.cxx:9162
TH1.cxx:9163
TH1.cxx:9164
TH1.cxx:9165
TH1.cxx:9166
TH1.cxx:9167
TH1.cxx:9168
TH1.cxx:9169
TH1.cxx:9170
TH1.cxx:9171
TH1.cxx:9172
TH1.cxx:9173
TH1.cxx:9174
TH1.cxx:9175
TH1.cxx:9176
TH1.cxx:9177
TH1.cxx:9178
TH1.cxx:9179
TH1.cxx:9180
TH1.cxx:9181
TH1.cxx:9182
TH1.cxx:9183
TH1.cxx:9184
TH1.cxx:9185
TH1.cxx:9186
TH1.cxx:9187
TH1.cxx:9188
TH1.cxx:9189
TH1.cxx:9190
TH1.cxx:9191
TH1.cxx:9192
TH1.cxx:9193
TH1.cxx:9194
TH1.cxx:9195
TH1.cxx:9196
TH1.cxx:9197
TH1.cxx:9198
TH1.cxx:9199
TH1.cxx:9200
TH1.cxx:9201
TH1.cxx:9202
TH1.cxx:9203
TH1.cxx:9204
TH1.cxx:9205
TH1.cxx:9206
TH1.cxx:9207
TH1.cxx:9208
TH1.cxx:9209
TH1.cxx:9210
TH1.cxx:9211
TH1.cxx:9212
TH1.cxx:9213
TH1.cxx:9214
TH1.cxx:9215
TH1.cxx:9216
TH1.cxx:9217
TH1.cxx:9218
TH1.cxx:9219
TH1.cxx:9220
TH1.cxx:9221
TH1.cxx:9222
TH1.cxx:9223
TH1.cxx:9224
TH1.cxx:9225
TH1.cxx:9226
TH1.cxx:9227
TH1.cxx:9228
TH1.cxx:9229
TH1.cxx:9230
TH1.cxx:9231
TH1.cxx:9232
TH1.cxx:9233
TH1.cxx:9234
TH1.cxx:9235
TH1.cxx:9236
TH1.cxx:9237
TH1.cxx:9238
TH1.cxx:9239
TH1.cxx:9240
TH1.cxx:9241
TH1.cxx:9242
TH1.cxx:9243
TH1.cxx:9244
TH1.cxx:9245
TH1.cxx:9246
TH1.cxx:9247
TH1.cxx:9248
TH1.cxx:9249
TH1.cxx:9250
TH1.cxx:9251
TH1.cxx:9252
TH1.cxx:9253
TH1.cxx:9254
TH1.cxx:9255
TH1.cxx:9256
TH1.cxx:9257
TH1.cxx:9258
TH1.cxx:9259
TH1.cxx:9260
TH1.cxx:9261
TH1.cxx:9262
TH1.cxx:9263
TH1.cxx:9264
TH1.cxx:9265
TH1.cxx:9266
TH1.cxx:9267
TH1.cxx:9268
TH1.cxx:9269
TH1.cxx:9270
TH1.cxx:9271
TH1.cxx:9272
TH1.cxx:9273
TH1.cxx:9274
TH1.cxx:9275
TH1.cxx:9276
TH1.cxx:9277
TH1.cxx:9278
TH1.cxx:9279
TH1.cxx:9280
TH1.cxx:9281
TH1.cxx:9282
TH1.cxx:9283
TH1.cxx:9284
TH1.cxx:9285
TH1.cxx:9286
TH1.cxx:9287
TH1.cxx:9288
TH1.cxx:9289
TH1.cxx:9290
TH1.cxx:9291
TH1.cxx:9292
TH1.cxx:9293
TH1.cxx:9294
TH1.cxx:9295
TH1.cxx:9296
TH1.cxx:9297
TH1.cxx:9298
TH1.cxx:9299
TH1.cxx:9300
TH1.cxx:9301
TH1.cxx:9302
TH1.cxx:9303
TH1.cxx:9304
TH1.cxx:9305
TH1.cxx:9306
TH1.cxx:9307
TH1.cxx:9308
TH1.cxx:9309
TH1.cxx:9310
TH1.cxx:9311
TH1.cxx:9312
TH1.cxx:9313
TH1.cxx:9314
TH1.cxx:9315
TH1.cxx:9316
TH1.cxx:9317
TH1.cxx:9318
TH1.cxx:9319
TH1.cxx:9320
TH1.cxx:9321
TH1.cxx:9322
TH1.cxx:9323
TH1.cxx:9324
TH1.cxx:9325
TH1.cxx:9326
TH1.cxx:9327
TH1.cxx:9328
TH1.cxx:9329
TH1.cxx:9330
TH1.cxx:9331
TH1.cxx:9332
TH1.cxx:9333
TH1.cxx:9334
TH1.cxx:9335
TH1.cxx:9336
TH1.cxx:9337
TH1.cxx:9338
TH1.cxx:9339
TH1.cxx:9340
TH1.cxx:9341
TH1.cxx:9342
TH1.cxx:9343
TH1.cxx:9344
TH1.cxx:9345
TH1.cxx:9346
TH1.cxx:9347
TH1.cxx:9348
TH1.cxx:9349
TH1.cxx:9350
TH1.cxx:9351
TH1.cxx:9352
TH1.cxx:9353
TH1.cxx:9354
TH1.cxx:9355
TH1.cxx:9356
TH1.cxx:9357
TH1.cxx:9358
TH1.cxx:9359
TH1.cxx:9360
TH1.cxx:9361
TH1.cxx:9362
TH1.cxx:9363
TH1.cxx:9364
TH1.cxx:9365
TH1.cxx:9366
TH1.cxx:9367
TH1.cxx:9368
TH1.cxx:9369
TH1.cxx:9370
TH1.cxx:9371
TH1.cxx:9372
TH1.cxx:9373
TH1.cxx:9374
TH1.cxx:9375
TH1.cxx:9376
TH1.cxx:9377
TH1.cxx:9378
TH1.cxx:9379
TH1.cxx:9380
TH1.cxx:9381
TH1.cxx:9382
TH1.cxx:9383
TH1.cxx:9384
TH1.cxx:9385
TH1.cxx:9386
TH1.cxx:9387
TH1.cxx:9388
TH1.cxx:9389
TH1.cxx:9390
TH1.cxx:9391
TH1.cxx:9392
TH1.cxx:9393
TH1.cxx:9394
TH1.cxx:9395
TH1.cxx:9396
TH1.cxx:9397
TH1.cxx:9398
TH1.cxx:9399
TH1.cxx:9400
TH1.cxx:9401
TH1.cxx:9402
TH1.cxx:9403
TH1.cxx:9404
TH1.cxx:9405
TH1.cxx:9406
TH1.cxx:9407
TH1.cxx:9408
TH1.cxx:9409
TH1.cxx:9410
TH1.cxx:9411
TH1.cxx:9412
TH1.cxx:9413
TH1.cxx:9414
TH1.cxx:9415
TH1.cxx:9416
TH1.cxx:9417
TH1.cxx:9418
TH1.cxx:9419
TH1.cxx:9420
TH1.cxx:9421
TH1.cxx:9422
TH1.cxx:9423
TH1.cxx:9424
TH1.cxx:9425
TH1.cxx:9426
TH1.cxx:9427
TH1.cxx:9428
TH1.cxx:9429
TH1.cxx:9430
TH1.cxx:9431
TH1.cxx:9432
TH1.cxx:9433
TH1.cxx:9434
TH1.cxx:9435
TH1.cxx:9436
TH1.cxx:9437
TH1.cxx:9438
TH1.cxx:9439
TH1.cxx:9440
TH1.cxx:9441
TH1.cxx:9442
TH1.cxx:9443
TH1.cxx:9444
TH1.cxx:9445
TH1.cxx:9446
TH1.cxx:9447
TH1.cxx:9448
TH1.cxx:9449
TH1.cxx:9450
TH1.cxx:9451
TH1.cxx:9452
TH1.cxx:9453
TH1.cxx:9454
TH1.cxx:9455
TH1.cxx:9456
TH1.cxx:9457
TH1.cxx:9458
TH1.cxx:9459
TH1.cxx:9460
TH1.cxx:9461
TH1.cxx:9462
TH1.cxx:9463
TH1.cxx:9464
TH1.cxx:9465
TH1.cxx:9466
TH1.cxx:9467
TH1.cxx:9468
TH1.cxx:9469
TH1.cxx:9470
TH1.cxx:9471
TH1.cxx:9472
TH1.cxx:9473
TH1.cxx:9474
TH1.cxx:9475
TH1.cxx:9476
TH1.cxx:9477
TH1.cxx:9478
TH1.cxx:9479
TH1.cxx:9480
TH1.cxx:9481
TH1.cxx:9482
TH1.cxx:9483
TH1.cxx:9484
TH1.cxx:9485
TH1.cxx:9486
TH1.cxx:9487
TH1.cxx:9488
TH1.cxx:9489
TH1.cxx:9490
TH1.cxx:9491
TH1.cxx:9492
TH1.cxx:9493
TH1.cxx:9494
TH1.cxx:9495
TH1.cxx:9496
TH1.cxx:9497
TH1.cxx:9498
TH1.cxx:9499
TH1.cxx:9500
TH1.cxx:9501
TH1.cxx:9502
TH1.cxx:9503
TH1.cxx:9504
TH1.cxx:9505
TH1.cxx:9506
TH1.cxx:9507
TH1.cxx:9508
TH1.cxx:9509
TH1.cxx:9510
TH1.cxx:9511
TH1.cxx:9512
TH1.cxx:9513
TH1.cxx:9514
TH1.cxx:9515
TH1.cxx:9516
TH1.cxx:9517
TH1.cxx:9518
TH1.cxx:9519
TH1.cxx:9520
TH1.cxx:9521
TH1.cxx:9522
TH1.cxx:9523
TH1.cxx:9524
TH1.cxx:9525
TH1.cxx:9526
TH1.cxx:9527
TH1.cxx:9528
TH1.cxx:9529
TH1.cxx:9530
TH1.cxx:9531
TH1.cxx:9532
TH1.cxx:9533
TH1.cxx:9534
TH1.cxx:9535
TH1.cxx:9536
TH1.cxx:9537
TH1.cxx:9538
TH1.cxx:9539
TH1.cxx:9540
TH1.cxx:9541
TH1.cxx:9542
TH1.cxx:9543
TH1.cxx:9544
TH1.cxx:9545
TH1.cxx:9546
TH1.cxx:9547
TH1.cxx:9548
TH1.cxx:9549
TH1.cxx:9550
TH1.cxx:9551
TH1.cxx:9552
TH1.cxx:9553
TH1.cxx:9554
TH1.cxx:9555
TH1.cxx:9556
TH1.cxx:9557
TH1.cxx:9558
TH1.cxx:9559
TH1.cxx:9560
TH1.cxx:9561
TH1.cxx:9562
TH1.cxx:9563
TH1.cxx:9564
TH1.cxx:9565
TH1.cxx:9566
TH1.cxx:9567
TH1.cxx:9568
TH1.cxx:9569
TH1.cxx:9570
TH1.cxx:9571
TH1.cxx:9572
TH1.cxx:9573
TH1.cxx:9574
TH1.cxx:9575
TH1.cxx:9576
TH1.cxx:9577
TH1.cxx:9578
TH1.cxx:9579
TH1.cxx:9580
TH1.cxx:9581
TH1.cxx:9582
TH1.cxx:9583
TH1.cxx:9584
TH1.cxx:9585
TH1.cxx:9586
TH1.cxx:9587
TH1.cxx:9588
TH1.cxx:9589
TH1.cxx:9590
TH1.cxx:9591
TH1.cxx:9592
TH1.cxx:9593
TH1.cxx:9594
TH1.cxx:9595
TH1.cxx:9596
TH1.cxx:9597
TH1.cxx:9598
TH1.cxx:9599
TH1.cxx:9600
TH1.cxx:9601
TH1.cxx:9602
TH1.cxx:9603
TH1.cxx:9604
TH1.cxx:9605
TH1.cxx:9606
TH1.cxx:9607
TH1.cxx:9608
TH1.cxx:9609
TH1.cxx:9610
TH1.cxx:9611
TH1.cxx:9612
TH1.cxx:9613
TH1.cxx:9614
TH1.cxx:9615
TH1.cxx:9616
TH1.cxx:9617
TH1.cxx:9618
TH1.cxx:9619
TH1.cxx:9620
TH1.cxx:9621
TH1.cxx:9622
TH1.cxx:9623
TH1.cxx:9624
TH1.cxx:9625
TH1.cxx:9626
TH1.cxx:9627
TH1.cxx:9628
TH1.cxx:9629
TH1.cxx:9630
TH1.cxx:9631
TH1.cxx:9632
TH1.cxx:9633
TH1.cxx:9634
TH1.cxx:9635
TH1.cxx:9636
TH1.cxx:9637
TH1.cxx:9638
TH1.cxx:9639
TH1.cxx:9640
TH1.cxx:9641
TH1.cxx:9642
TH1.cxx:9643
TH1.cxx:9644
TH1.cxx:9645
TH1.cxx:9646
TH1.cxx:9647
TH1.cxx:9648
TH1.cxx:9649
TH1.cxx:9650
TH1.cxx:9651
TH1.cxx:9652
TH1.cxx:9653
TH1.cxx:9654
TH1.cxx:9655
TH1.cxx:9656
TH1.cxx:9657
TH1.cxx:9658
TH1.cxx:9659
TH1.cxx:9660
TH1.cxx:9661
TH1.cxx:9662
TH1.cxx:9663
TH1.cxx:9664
TH1.cxx:9665
TH1.cxx:9666
TH1.cxx:9667
TH1.cxx:9668
TH1.cxx:9669
TH1.cxx:9670
TH1.cxx:9671
TH1.cxx:9672
TH1.cxx:9673
TH1.cxx:9674
TH1.cxx:9675
TH1.cxx:9676
TH1.cxx:9677
TH1.cxx:9678
TH1.cxx:9679
TH1.cxx:9680
TH1.cxx:9681
TH1.cxx:9682
TH1.cxx:9683
TH1.cxx:9684
TH1.cxx:9685
TH1.cxx:9686
TH1.cxx:9687
TH1.cxx:9688
TH1.cxx:9689
TH1.cxx:9690
TH1.cxx:9691
TH1.cxx:9692
TH1.cxx:9693
TH1.cxx:9694
TH1.cxx:9695
TH1.cxx:9696
TH1.cxx:9697
TH1.cxx:9698
TH1.cxx:9699
TH1.cxx:9700
TH1.cxx:9701
TH1.cxx:9702
TH1.cxx:9703
TH1.cxx:9704
TH1.cxx:9705
TH1.cxx:9706
TH1.cxx:9707
TH1.cxx:9708
TH1.cxx:9709
TH1.cxx:9710
TH1.cxx:9711
TH1.cxx:9712
TH1.cxx:9713
TH1.cxx:9714
TH1.cxx:9715
TH1.cxx:9716
TH1.cxx:9717
TH1.cxx:9718
TH1.cxx:9719
TH1.cxx:9720
TH1.cxx:9721
TH1.cxx:9722
TH1.cxx:9723
TH1.cxx:9724
TH1.cxx:9725
TH1.cxx:9726
TH1.cxx:9727
TH1.cxx:9728
TH1.cxx:9729
TH1.cxx:9730
TH1.cxx:9731
TH1.cxx:9732
TH1.cxx:9733
TH1.cxx:9734
TH1.cxx:9735
TH1.cxx:9736
TH1.cxx:9737
TH1.cxx:9738
TH1.cxx:9739
TH1.cxx:9740
TH1.cxx:9741
TH1.cxx:9742
TH1.cxx:9743
TH1.cxx:9744
TH1.cxx:9745
TH1.cxx:9746
TH1.cxx:9747
TH1.cxx:9748
TH1.cxx:9749
TH1.cxx:9750
TH1.cxx:9751
TH1.cxx:9752
TH1.cxx:9753
TH1.cxx:9754
TH1.cxx:9755
TH1.cxx:9756
TH1.cxx:9757
TH1.cxx:9758
TH1.cxx:9759
TH1.cxx:9760
TH1.cxx:9761
TH1.cxx:9762
TH1.cxx:9763
TH1.cxx:9764
TH1.cxx:9765
TH1.cxx:9766
TH1.cxx:9767
TH1.cxx:9768
TH1.cxx:9769
TH1.cxx:9770
TH1.cxx:9771
TH1.cxx:9772
TH1.cxx:9773
TH1.cxx:9774
TH1.cxx:9775
TH1.cxx:9776
TH1.cxx:9777
TH1.cxx:9778
TH1.cxx:9779
TH1.cxx:9780
TH1.cxx:9781
TH1.cxx:9782
TH1.cxx:9783
TH1.cxx:9784
TH1.cxx:9785
TH1.cxx:9786
TH1.cxx:9787
TH1.cxx:9788
TH1.cxx:9789
TH1.cxx:9790
TH1.cxx:9791
TH1.cxx:9792
TH1.cxx:9793
TH1.cxx:9794
TH1.cxx:9795
TH1.cxx:9796
TH1.cxx:9797
TH1.cxx:9798
TH1.cxx:9799
TH1.cxx:9800
TH1.cxx:9801
TH1.cxx:9802
TH1.cxx:9803
TH1.cxx:9804
TH1.cxx:9805
TH1.cxx:9806
TH1.cxx:9807
TH1.cxx:9808
TH1.cxx:9809
TH1.cxx:9810
TH1.cxx:9811
TH1.cxx:9812
TH1.cxx:9813
TH1.cxx:9814
TH1.cxx:9815
TH1.cxx:9816
TH1.cxx:9817
TH1.cxx:9818
TH1.cxx:9819
TH1.cxx:9820
TH1.cxx:9821
TH1.cxx:9822
TH1.cxx:9823
TH1.cxx:9824
TH1.cxx:9825
TH1.cxx:9826
TH1.cxx:9827
TH1.cxx:9828
TH1.cxx:9829
TH1.cxx:9830
TH1.cxx:9831
TH1.cxx:9832
TH1.cxx:9833
TH1.cxx:9834
TH1.cxx:9835
TH1.cxx:9836
TH1.cxx:9837
TH1.cxx:9838
TH1.cxx:9839
TH1.cxx:9840
TH1.cxx:9841
TH1.cxx:9842
TH1.cxx:9843
TH1.cxx:9844
TH1.cxx:9845
TH1.cxx:9846
TH1.cxx:9847
TH1.cxx:9848
TH1.cxx:9849
TH1.cxx:9850
TH1.cxx:9851
TH1.cxx:9852
TH1.cxx:9853
TH1.cxx:9854
TH1.cxx:9855
TH1.cxx:9856
TH1.cxx:9857
TH1.cxx:9858
TH1.cxx:9859
TH1.cxx:9860
TH1.cxx:9861
TH1.cxx:9862
TH1.cxx:9863
TH1.cxx:9864
TH1.cxx:9865
TH1.cxx:9866
TH1.cxx:9867
TH1.cxx:9868
TH1.cxx:9869
TH1.cxx:9870
TH1.cxx:9871
TH1.cxx:9872
TH1.cxx:9873
TH1.cxx:9874
TH1.cxx:9875
TH1.cxx:9876
TH1.cxx:9877
TH1.cxx:9878
TH1.cxx:9879
TH1.cxx:9880
TH1.cxx:9881
TH1.cxx:9882
TH1.cxx:9883
TH1.cxx:9884
TH1.cxx:9885
TH1.cxx:9886
TH1.cxx:9887
TH1.cxx:9888
TH1.cxx:9889
TH1.cxx:9890
TH1.cxx:9891
TH1.cxx:9892
TH1.cxx:9893
TH1.cxx:9894
TH1.cxx:9895
TH1.cxx:9896
TH1.cxx:9897
TH1.cxx:9898
TH1.cxx:9899
TH1.cxx:9900
TH1.cxx:9901
TH1.cxx:9902
TH1.cxx:9903
TH1.cxx:9904
TH1.cxx:9905
TH1.cxx:9906
TH1.cxx:9907
TH1.cxx:9908
TH1.cxx:9909
TH1.cxx:9910
TH1.cxx:9911
TH1.cxx:9912
TH1.cxx:9913
TH1.cxx:9914
TH1.cxx:9915
TH1.cxx:9916
TH1.cxx:9917
TH1.cxx:9918
TH1.cxx:9919
TH1.cxx:9920
TH1.cxx:9921
TH1.cxx:9922
TH1.cxx:9923
TH1.cxx:9924
TH1.cxx:9925
TH1.cxx:9926
TH1.cxx:9927
TH1.cxx:9928
TH1.cxx:9929
TH1.cxx:9930
TH1.cxx:9931
TH1.cxx:9932
TH1.cxx:9933
TH1.cxx:9934
TH1.cxx:9935
TH1.cxx:9936
TH1.cxx:9937
TH1.cxx:9938
TH1.cxx:9939
TH1.cxx:9940
TH1.cxx:9941
TH1.cxx:9942
TH1.cxx:9943
TH1.cxx:9944
TH1.cxx:9945
TH1.cxx:9946
TH1.cxx:9947
TH1.cxx:9948
TH1.cxx:9949
TH1.cxx:9950
TH1.cxx:9951
TH1.cxx:9952
TH1.cxx:9953
TH1.cxx:9954
TH1.cxx:9955
TH1.cxx:9956
TH1.cxx:9957
TH1.cxx:9958
TH1.cxx:9959
TH1.cxx:9960
TH1.cxx:9961
TH1.cxx:9962
TH1.cxx:9963
TH1.cxx:9964
TH1.cxx:9965
TH1.cxx:9966
TH1.cxx:9967
TH1.cxx:9968
TH1.cxx:9969
TH1.cxx:9970
TH1.cxx:9971
TH1.cxx:9972
TH1.cxx:9973
TH1.cxx:9974
TH1.cxx:9975
TH1.cxx:9976
TH1.cxx:9977
TH1.cxx:9978
TH1.cxx:9979
TH1.cxx:9980
TH1.cxx:9981
TH1.cxx:9982
TH1.cxx:9983
TH1.cxx:9984
TH1.cxx:9985
TH1.cxx:9986
TH1.cxx:9987
TH1.cxx:9988
TH1.cxx:9989
TH1.cxx:9990
TH1.cxx:9991
TH1.cxx:9992
TH1.cxx:9993
TH1.cxx:9994
TH1.cxx:9995
TH1.cxx:9996
TH1.cxx:9997
TH1.cxx:9998
TH1.cxx:9999
TH1.cxx:10000
TH1.cxx:10001
TH1.cxx:10002
TH1.cxx:10003
TH1.cxx:10004
TH1.cxx:10005
TH1.cxx:10006
TH1.cxx:10007
TH1.cxx:10008
TH1.cxx:10009
TH1.cxx:10010
TH1.cxx:10011
TH1.cxx:10012
TH1.cxx:10013
TH1.cxx:10014
TH1.cxx:10015
TH1.cxx:10016
TH1.cxx:10017
TH1.cxx:10018
TH1.cxx:10019
TH1.cxx:10020
TH1.cxx:10021
TH1.cxx:10022
TH1.cxx:10023
TH1.cxx:10024
TH1.cxx:10025
TH1.cxx:10026
TH1.cxx:10027
TH1.cxx:10028
TH1.cxx:10029
TH1.cxx:10030
TH1.cxx:10031
TH1.cxx:10032
TH1.cxx:10033
TH1.cxx:10034
TH1.cxx:10035
TH1.cxx:10036
TH1.cxx:10037
TH1.cxx:10038
TH1.cxx:10039
TH1.cxx:10040
TH1.cxx:10041
TH1.cxx:10042
TH1.cxx:10043
TH1.cxx:10044
TH1.cxx:10045
TH1.cxx:10046
TH1.cxx:10047
TH1.cxx:10048
TH1.cxx:10049
TH1.cxx:10050
TH1.cxx:10051
TH1.cxx:10052
TH1.cxx:10053
TH1.cxx:10054
TH1.cxx:10055
TH1.cxx:10056
TH1.cxx:10057
TH1.cxx:10058
TH1.cxx:10059
TH1.cxx:10060
TH1.cxx:10061
TH1.cxx:10062