// @(#)root/minuit:$Id$
// Author: Anna Kreshuk 04/03/2005

/*************************************************************************
 * Copyright (C) 1995-2005, 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 "TLinearFitter.h"
#include "TMath.h"
#include "TDecompChol.h"
#include "TGraph.h"
#include "TGraph2D.h"
#include "TMultiGraph.h"
#include "TRandom2.h"
#include "TObjString.h"
#include "TF2.h"
#include "TH1.h"
#include "TList.h"


ClassImp(TLinearFitter)

//////////////////////////////////////////////////////////////////////////
//
// The Linear Fitter - fitting functions that are LINEAR IN PARAMETERS
//
// Linear fitter is used to fit a set of data points with a linear
// combination of specified functions. Note, that "linear" in the name
// stands only for the model dependency on parameters, the specified
// functions can be nonlinear.
// The general form of this kind of model is
//
//          y(x) = a[0] + a[1]*f[1](x)+...a[n]*f[n](x)
//
// Functions f are fixed functions of x. For example, fitting with a
// polynomial is linear fitting in this sense.
//
//                         The fitting method
//
// The fit is performed using the Normal Equations method with Cholesky
// decomposition.
//
//                         Why should it be used?
//
// The linear fitter is considerably faster than general non-linear
// fitters and doesn't require to set the initial values of parameters.
//
//                          Using the fitter:
//
// 1.Adding the data points:
//  1.1 To store or not to store the input data?
//      - There are 2 options in the constructor - to store or not
//        store the input data. The advantages of storing the data
//        are that you'll be able to reset the fitting model without
//        adding all the points again, and that for very large sets
//        of points the chisquare is calculated more precisely.
//        The obvious disadvantage is the amount of memory used to
//        keep all the points.
//      - Before you start adding the points, you can change the
//        store/not store option by StoreData() method.
//  1.2 The data can be added:
//      - simply point by point - AddPoint() method
//      - an array of points at once:
//        If the data is already stored in some arrays, this data
//        can be assigned to the linear fitter without physically
//        coping bytes, thanks to the Use() method of
//        TVector and TMatrix classes - AssignData() method
//
// 2.Setting the formula
//  2.1 The linear formula syntax:
//      -Additive parts are separated by 2 plus signes "++"
//       --for example "1 ++ x" - for fitting a straight line
//      -All standard functions, undrestood by TFormula, can be used
//       as additive parts
//       --TMath functions can be used too
//      -Functions, used as additive parts, shouldn't have any parameters,
//       even if those parameters are set.
//       --for example, if normalizing a sum of a gaus(0, 1) and a
//         gaus(0, 2), don't use the built-in "gaus" of TFormula,
//         because it has parameters, take TMath::Gaus(x, 0, 1) instead.
//      -Polynomials can be used like "pol3", .."polN"
//      -If fitting a more than 3-dimensional formula, variables should
//       be numbered as follows:
//       -- x[0], x[1], x[2]... For example, to fit  "1 ++ x[0] ++ x[1] ++ x[2] ++ x[3]*x[3]"
//  2.2 Setting the formula:
//    2.2.1 If fitting a 1-2-3-dimensional formula, one can create a
//          TF123 based on a linear expression and pass this function
//          to the fitter:
//          --Example:
//            TLinearFitter *lf = new TLinearFitter();
//            TF2 *f2 = new TF2("f2", "x ++ y ++ x*x*y*y", -2, 2, -2, 2);
//            lf->SetFormula(f2);
//          --The results of the fit are then stored in the function,
//            just like when the TH1::Fit or TGraph::Fit is used
//          --A linear function of this kind is by no means different
//            from any other function, it can be drawn, evaluated, etc.
//
//          --For multidimensional fitting, TFormulas of the form:
//            x[0]++...++x[n] can be used
//    2.2.2 There is no need to create the function if you don't want to,
//          the formula can be set by expression:
//          --Example:
//            // 2 is the number of dimensions
//            TLinearFitter *lf = new TLinearFitter(2);
//            lf->SetFormula("x ++ y ++ x*x*y*y");
//
//    2.2.3 The fastest functions to compute are polynomials and hyperplanes.
//          --Polynomials are set the usual way: "pol1", "pol2",...
//          --Hyperplanes are set by expression "hyp3", "hyp4", ...
//          ---The "hypN" expressions only work when the linear fitter
//             is used directly, not through TH1::Fit or TGraph::Fit.
//             To fit a graph or a histogram with a hyperplane, define
//             the function as "1++x++y".
//          ---A constant term is assumed for a hyperplane, when using
//             the "hypN" expression, so "hyp3" is in fact fitting with
//             "1++x++y++z" function.
//          --Fitting hyperplanes is much faster than fitting other
//            expressions so if performance is vital, calculate the
//            function values beforehand and give them to the fitter
//            as variables
//          --Example:
//            You want to fit "sin(x)|cos(2*x)" very fast. Calculate
//            sin(x) and cos(2*x) beforehand and store them in array *data.
//            Then:
//            TLinearFitter *lf=new TLinearFitter(2, "hyp2");
//            lf->AssignData(npoint, 2, data, y);
//
//  2.3 Resetting the formula
//    2.3.1 If the input data is stored (or added via AssignData() function),
//          the fitting formula can be reset without re-adding all the points.
//          --Example:
//            TLinearFitter *lf=new TLinearFitter("1++x++x*x");
//            lf->AssignData(n, 1, x, y, e);
//            lf->Eval()
//            //looking at the parameter significance, you see,
//            // that maybe the fit will improve, if you take out
//            // the constant term
//            lf->SetFormula("x++x*x");
//            lf->Eval();
//            ...
//    2.3.2 If the input data is not stored, the fitter will have to be
//          cleared and the data will have to be added again to try a
//          different formula.
//
// 3.Accessing the fit results
//  3.1 There are methods in the fitter to access all relevant information:
//      --GetParameters, GetCovarianceMatrix, etc
//      --the t-values of parameters and their significance can be reached by
//        GetParTValue() and GetParSignificance() methods
//  3.2 If fitting with a pre-defined TF123, the fit results are also
//      written into this function.
//
///////////////////////////////////////////////////////////////////////////
// 4.Robust fitting - Least Trimmed Squares regression (LTS)
//   Outliers are atypical(by definition), infrequant observations; data points
//   which do not appear to follow the characteristic distribution of the rest
//   of the data. These may reflect genuine properties of the underlying
//   phenomenon(variable), or be due to measurement errors or anomalies which
//   shouldn't be modelled. (StatSoft electronic textbook)
//
//   Even a single gross outlier can greatly influence the results of least-
//   squares fitting procedure, and in this case use of robust(resistant) methods
//   is recommended.
//
//   The method implemented here is based on the article and algorithm:
//   "Computing LTS Regression for Large Data Sets" by
//   P.J.Rousseeuw and Katrien Van Driessen
//   The idea of the method is to find the fitting coefficients for a subset
//   of h observations (out of n) with the smallest sum of squared residuals.
//   The size of the subset h should lie between (npoints + nparameters +1)/2
//   and n, and represents the minimal number of good points in the dataset.
//   The default value is set to (npoints + nparameters +1)/2, but of course
//   if you are sure that the data contains less outliers it's better to change
//   h according to your data.
//
//   To perform a robust fit, call EvalRobust() function instead of Eval() after
//   adding the points and setting the fitting function.
//   Note, that standard errors on parameters are not computed!
//
//////////////////////////////////////////////////////////////////////////



//______________________________________________________________________________
TLinearFitter::TLinearFitter() :
TVirtualFitter(),
   fParams(),
   fParCovar(),
   fTValues(),
   fDesign(),
   fDesignTemp(),
   fDesignTemp2(),
   fDesignTemp3(),
   fAtb(),
   fAtbTemp(),
   fAtbTemp2(),
   fAtbTemp3(),
   fFunctions(),
   fY(),
   fX(),
   fE(),
   fVal()
{
   //default c-tor, input data is stored
   //If you don't want to store the input data,
   //run the function StoreData(kFALSE) after constructor

   fChisquare =0;
   fNpoints   =0;
   fNdim      =0;
   fY2        =0;
   fY2Temp    =0;
   fNfixed    =0;
   fIsSet     =kFALSE;
   fFormula   =0;
   fFixedParams=0;
   fSpecial   =0;
   fInputFunction=0;
   fStoreData =kTRUE;
   fRobust    =kFALSE;
   fNfunctions = 0;
   fFormulaSize = 0;
   fH = 0;
}

//______________________________________________________________________________
TLinearFitter::TLinearFitter(Int_t ndim) :
   fVal()
{
   //The parameter stands for number of dimensions in the fitting formula
   //The input data is stored. If you don't want to store the input data,
   //run the function StoreData(kFALSE) after constructor

   fNdim    =ndim;
   fNpoints =0;
   fY2      =0;
   fY2Temp  =0;
   fNfixed  =0;
   fFixedParams=0;
   fFormula =0;
   fIsSet   =kFALSE;
   fChisquare=0;
   fSpecial  =0;
   fInputFunction=0;
   fStoreData=kTRUE;
   fRobust = kFALSE;
   fNfunctions = 0;
   fFormulaSize = 0;
   fH = 0;
}

//______________________________________________________________________________
TLinearFitter::TLinearFitter(Int_t ndim, const char *formula, Option_t *opt)
{
   //First parameter stands for number of dimensions in the fitting formula
   //Second parameter is the fitting formula: see class description for formula syntax
   //Options:
   //The option is to store or not to store the data
   //If you don't want to store the data, choose "" for the option, or run
   //StoreData(kFalse) member function after the constructor

   fNdim=ndim;
   fNpoints=0;
   fChisquare=0;
   fY2=0;
   fNfixed=0;
   fFixedParams=0;
   fSpecial=0;
   fInputFunction=0;
   fFormula = 0;
   TString option=opt;
   option.ToUpper();
   if (option.Contains("D"))
      fStoreData=kTRUE;
   else
      fStoreData=kFALSE;
   fRobust=kFALSE;
   SetFormula(formula);
}

//______________________________________________________________________________
TLinearFitter::TLinearFitter(TFormula *function, Option_t *opt)
{
   //This constructor uses a linear function. How to create it?
   //TFormula now accepts formulas of the following kind:
   //TFormula("f", "x++y++z++x*x") or
   //TFormula("f", "x[0]++x[1]++x[2]*x[2]");
   //Other than the look, it's in no
   //way different from the regular formula, it can be evaluated,
   //drawn, etc.
   //The option is to store or not to store the data
   //If you don't want to store the data, choose "" for the option, or run
   //StoreData(kFalse) member function after the constructor

   fNdim=function->GetNdim();
   if (!function->IsLinear()){
      Int_t number=function->GetNumber();
      if (number<299 || number>310){
         Error("TLinearFitter", "Trying to fit with a nonlinear function");
         return;
      }
   }
   fNpoints=0;
   fChisquare=0;
   fY2=0;
   fNfixed=0;
   fFixedParams=0;
   fSpecial=0;
   fFormula = 0;
   TString option=opt;
   option.ToUpper();
   if (option.Contains("D"))
      fStoreData=kTRUE;
   else
      fStoreData=kFALSE;
   fIsSet=kTRUE;
   fRobust=kFALSE;
   fInputFunction=0;

   SetFormula(function);
}

//______________________________________________________________________________
TLinearFitter::TLinearFitter(const TLinearFitter& tlf) :
   TVirtualFitter(tlf),
   fParams(tlf.fParams),
   fParCovar(tlf.fParCovar),
   fTValues(tlf.fTValues),
   fParSign(tlf.fParSign),
   fDesign(tlf.fDesign),
   fDesignTemp(tlf.fDesignTemp),
   fDesignTemp2(tlf.fDesignTemp2),
   fDesignTemp3(tlf.fDesignTemp3),
   fAtb(tlf.fAtb),
   fAtbTemp(tlf.fAtbTemp),
   fAtbTemp2(tlf.fAtbTemp2),
   fAtbTemp3(tlf.fAtbTemp3),
   fFunctions( * (TObjArray *)tlf.fFunctions.Clone()),
   fY(tlf.fY),
   fY2(tlf.fY2),
   fY2Temp(tlf.fY2Temp),
   fX(tlf.fX),
   fE(tlf.fE),
   fInputFunction(tlf.fInputFunction),
   fVal(),
   fNpoints(tlf.fNpoints),
   fNfunctions(tlf.fNfunctions),
   fFormulaSize(tlf.fFormulaSize),
   fNdim(tlf.fNdim),
   fNfixed(tlf.fNfixed),
   fSpecial(tlf.fSpecial),
   fFormula(0),
   fIsSet(tlf.fIsSet),
   fStoreData(tlf.fStoreData),
   fChisquare(tlf.fChisquare),
   fH(tlf.fH),
   fRobust(tlf.fRobust),
   fFitsample(tlf.fFitsample),
   fFixedParams(0)
{
   // Copy ctor

   // make a deep  copy of managed objects
   // fFormula, fFixedParams and fFunctions

   if ( tlf.fFixedParams && fNfixed > 0 ) {
      fFixedParams=new Bool_t[fNfixed];
      for(Int_t i=0; i<fNfixed; ++i)
         fFixedParams[i]=tlf.fFixedParams[i];
   }
   if (tlf.fFormula) {
      fFormula = new char[fFormulaSize+1];
      strlcpy(fFormula,tlf.fFormula,fFormulaSize+1);
   }

}


//______________________________________________________________________________
TLinearFitter::~TLinearFitter()
{
   // Linear fitter cleanup.

   if (fFormula) {
      delete [] fFormula;
      fFormula = 0;
   }
   if (fFixedParams) {
      delete [] fFixedParams;
      fFixedParams = 0;
   }
   fInputFunction = 0;
   fFunctions.Delete();

}

//______________________________________________________________________________
TLinearFitter& TLinearFitter::operator=(const TLinearFitter& tlf)
{
   // Assignment operator

   if(this!=&tlf) {

      TVirtualFitter::operator=(tlf);
      fParams.ResizeTo(tlf.fParams);      fParams=tlf.fParams;
      fParCovar.ResizeTo(tlf.fParCovar);  fParCovar=tlf.fParCovar;
      fTValues.ResizeTo(tlf.fTValues);    fTValues=tlf.fTValues;
      fParSign.ResizeTo(tlf.fParSign);    fParSign=tlf.fParSign;
      fDesign.ResizeTo(tlf.fDesign);                fDesign=tlf.fDesign;
      fDesignTemp.ResizeTo(tlf.fDesignTemp);        fDesignTemp=tlf.fDesignTemp;
      fDesignTemp2.ResizeTo(tlf.fDesignTemp2);      fDesignTemp2=tlf.fDesignTemp2;
      fDesignTemp3.ResizeTo(tlf.fDesignTemp3);      fDesignTemp3=tlf.fDesignTemp3;

      fAtb.ResizeTo(tlf.fAtb);            fAtb=tlf.fAtb;
      fAtbTemp.ResizeTo(tlf.fAtbTemp);    fAtbTemp=tlf.fAtbTemp;
      fAtbTemp2.ResizeTo(tlf.fAtbTemp2);    fAtbTemp2=tlf.fAtbTemp2;
      fAtbTemp3.ResizeTo(tlf.fAtbTemp3);    fAtbTemp3=tlf.fAtbTemp3;

      fFunctions.Delete();
      fFunctions= *(TObjArray*) tlf.fFunctions.Clone();

      fY.ResizeTo(tlf.fY);    fY = tlf.fY;
      fX.ResizeTo(tlf.fX);    fX = tlf.fX;
      fE.ResizeTo(tlf.fE);    fE = tlf.fE;

      fY2 = tlf.fY2;
      fY2Temp = tlf.fY2Temp;
      for(Int_t i = 0; i < 1000; i++) fVal[i] = tlf.fVal[i];

      if(fInputFunction) delete fInputFunction; fInputFunction = 0;
      if(tlf.fInputFunction) fInputFunction = new TFormula(*tlf.fInputFunction);

      fNpoints=tlf.fNpoints;
      fNfunctions=tlf.fNfunctions;
      fFormulaSize=tlf.fFormulaSize;
      fNdim=tlf.fNdim;
      fNfixed=tlf.fNfixed;
      fSpecial=tlf.fSpecial;

      if(fFormula) delete [] fFormula; fFormula = 0;
      if (tlf.fFormula) {
         fFormula = new char[fFormulaSize+1];
         strlcpy(fFormula,tlf.fFormula,fFormulaSize+1);
      }

      fIsSet=tlf.fIsSet;
      fStoreData=tlf.fStoreData;
      fChisquare=tlf.fChisquare;

      fH=tlf.fH;
      fRobust=tlf.fRobust;
      fFitsample=tlf.fFitsample;

      if(fFixedParams) delete [] fFixedParams; fFixedParams = 0;
      if ( tlf.fFixedParams && fNfixed > 0 ) {
         fFixedParams=new Bool_t[fNfixed];
         for(Int_t i=0; i< fNfixed; ++i)
            fFixedParams[i]=tlf.fFixedParams[i];
      }

   }
   return *this;
}

//______________________________________________________________________________
void TLinearFitter::Add(TLinearFitter *tlf)
{
//Add another linear fitter to this linear fitter. Points and Design matrices
//are added, but the previos fitting results (if any) are deleted.
//Fitters must have same formulas (this is not checked). Fixed parameters are not changed

   fParams.Zero();
   fParCovar.Zero();
   fTValues.Zero();
   fParSign.Zero();

   fDesign += tlf->fDesign;

   fDesignTemp += tlf->fDesignTemp;
   fDesignTemp2 += tlf->fDesignTemp2;
   fDesignTemp3 += tlf->fDesignTemp3;
   fAtb += tlf->fAtb;
   fAtbTemp += tlf->fAtbTemp;
   fAtbTemp2 += tlf->fAtbTemp2;
   fAtbTemp3 += tlf->fAtbTemp3;

   if (fStoreData){
      Int_t size=fY.GetNoElements();
      Int_t newsize = fNpoints+tlf->fNpoints;
      if (size<newsize){
         fY.ResizeTo(newsize);
         fE.ResizeTo(newsize);
         fX.ResizeTo(newsize, fNdim);
      }
      for (Int_t i=fNpoints; i<newsize; i++){
         fY(i)=tlf->fY(i-fNpoints);
         fE(i)=tlf->fE(i-fNpoints);
         for (Int_t j=0; j<fNdim; j++){
            fX(i,j)=tlf->fX(i-fNpoints, j);
         }
      }
   }
   fY2 += tlf->fY2;
   fY2Temp += tlf->fY2Temp;
   fNpoints += tlf->fNpoints;
   //fInputFunction=(TFormula*)tlf.fInputFunction->Clone();

   fChisquare=0;
   fH=0;
   fRobust=0;
}

//______________________________________________________________________________
void TLinearFitter::AddPoint(Double_t *x, Double_t y, Double_t e)
{
   //Adds 1 point to the fitter.
   //First parameter stands for the coordinates of the point, where the function is measured
   //Second parameter - the value being fitted
   //Third parameter - weight(measurement error) of this point (=1 by default)

   Int_t size;
   fNpoints++;
   if (fStoreData){
      size=fY.GetNoElements();
      if (size<fNpoints){
         fY.ResizeTo(fNpoints+fNpoints/2);
         fE.ResizeTo(fNpoints+fNpoints/2);
         fX.ResizeTo(fNpoints+fNpoints/2, fNdim);
      }

      Int_t j=fNpoints-1;
      fY(j)=y;
      fE(j)=e;
      for (Int_t i=0; i<fNdim; i++)
         fX(j,i)=x[i];
   }
   //add the point to the design matrix, if the formula has been set
   // (LM: why condition !fRobust ?? - remove it to fix Coverity 11602)
   // when 100< fSpecial < 200 (Polynomial) fFunctions is not empty
   // (see implementation of SetFormula method)
   if (fFunctions.IsEmpty()&&(!fInputFunction)&&(fSpecial<=200)){
      Error("AddPoint", "Point can't be added, because the formula hasn't been set");
      return;
   }
   if (!fRobust) AddToDesign(x, y, e);
}

//______________________________________________________________________________
void TLinearFitter::AssignData(Int_t npoints, Int_t xncols, Double_t *x, Double_t *y, Double_t *e)
{
   //This function is to use when you already have all the data in arrays
   //and don't want to copy them into the fitter. In this function, the Use() method
   //of TVectorD and TMatrixD is used, so no bytes are physically moved around.
   //First parameter - number of points to fit
   //Second parameter - number of variables in the model
   //Third parameter - the variables of the model, stored in the following way:
   //(x0(0), x1(0), x2(0), x3(0), x0(1), x1(1), x2(1), x3(1),...

   if (npoints<fNpoints){
      Error("AddData", "Those points are already added");
      return;
   }
   Bool_t same=kFALSE;
   if (fX.GetMatrixArray()==x && fY.GetMatrixArray()==y){
      if (e){
         if (fE.GetMatrixArray()==e)
            same=kTRUE;
      }
   }

   fX.Use(npoints, xncols, x);
   fY.Use(npoints, y);
   if (e)
      fE.Use(npoints, e);
   else {
      fE.ResizeTo(npoints);
      fE=1;
   }
   Int_t xfirst;
   if (!fFunctions.IsEmpty() || fInputFunction ||  fSpecial>200) {
      if (same)
         xfirst=fNpoints;

      else
         xfirst=0;
      for (Int_t i=xfirst; i<npoints; i++)
         AddToDesign(TMatrixDRow(fX, i).GetPtr(), fY(i), fE(i));
   }
   fNpoints=npoints;
}

//______________________________________________________________________________
void TLinearFitter::AddToDesign(Double_t *x, Double_t y, Double_t e)
{
   //Add a point to the AtA matrix and to the Atb vector.



   Int_t i, j, ii;
   y/=e;

//   Double_t fVal[1000];

   if ((fSpecial>100)&&(fSpecial<200)){
      //polynomial fitting
      Int_t npar=fSpecial-100;
      fVal[0]=1;
      for (i=1; i<npar; i++)
         fVal[i]=fVal[i-1]*x[0];
      for (i=0; i<npar; i++)
         fVal[i]/=e;
   } else if (fSpecial>200){
      //Hyperplane fitting. Constant term is added
      Int_t npar=fSpecial-201;
      fVal[0]=1./e;
      for (i=0; i<npar; i++)
         fVal[i+1]=x[i]/e;
   } else {
      //general case
      for (ii=0; ii<fNfunctions; ii++){
         if (!fFunctions.IsEmpty()){
            TFormula *f1 = (TFormula*)(fFunctions.UncheckedAt(ii));
            fVal[ii]=f1->EvalPar(x)/e;
         } else {
            TFormula *f=(TFormula*)fInputFunction->GetLinearPart(ii);
            if (!f){
               Error("AddToDesign","Function %s has no linear parts - maybe missing a ++ in the formula expression",fInputFunction->GetName());
               return;
            }
            fVal[ii]=f->EvalPar(x)/e;
         }
      }
   }
   //additional matrices for numerical stability
   for (i=0; i<fNfunctions; i++){
      for (j=0; j<i; j++)
         fDesignTemp3(j, i)+=fVal[i]*fVal[j];
      fDesignTemp3(i, i)+=fVal[i]*fVal[i];
      fAtbTemp3(i)+=fVal[i]*y;

   }
   fY2Temp+=y*y;
   fIsSet=kTRUE;

   if (fNpoints % 100 == 0 && fNpoints>100){
      fDesignTemp2+=fDesignTemp3;
      fDesignTemp3.Zero();
      fAtbTemp2+=fAtbTemp3;
      fAtbTemp3.Zero();
      if (fNpoints % 10000 == 0 && fNpoints>10000){
         fDesignTemp+=fDesignTemp2;
         fDesignTemp2.Zero();
         fAtbTemp+=fAtbTemp2;
         fAtbTemp2.Zero();
         fY2+=fY2Temp;
         fY2Temp=0;
         if (fNpoints % 1000000 == 0 && fNpoints>1000000){
            fDesign+=fDesignTemp;
            fDesignTemp.Zero();
            fAtb+=fAtbTemp;
            fAtbTemp.Zero();
         }
      }
   }
}

//______________________________________________________________________________
void TLinearFitter::AddTempMatrices()
{
   if (fDesignTemp3.GetNrows()>0){
      fDesignTemp2+=fDesignTemp3;
      fDesignTemp+=fDesignTemp2;
      fDesign+=fDesignTemp;
      fDesignTemp3.Zero();
      fDesignTemp2.Zero();
      fDesignTemp.Zero();
      fAtbTemp2+=fAtbTemp3;
      fAtbTemp+=fAtbTemp2;
      fAtb+=fAtbTemp;
      fAtbTemp3.Zero();
      fAtbTemp2.Zero();
      fAtbTemp.Zero();

      fY2+=fY2Temp;
      fY2Temp=0;
      }
}

//______________________________________________________________________________
void TLinearFitter::Clear(Option_t * /*option*/)
{
   //Clears everything. Used in TH1::Fit and TGraph::Fit().

   fParams.Clear();
   fParCovar.Clear();
   fTValues.Clear();
   fParSign.Clear();
   fDesign.Clear();
   fDesignTemp.Clear();
   fDesignTemp2.Clear();
   fDesignTemp3.Clear();
   fAtb.Clear();
   fAtbTemp.Clear();
   fAtbTemp2.Clear();
   fAtbTemp3.Clear();
   fFunctions.Clear();
   fInputFunction=0;
   fY.Clear();
   fX.Clear();
   fE.Clear();

   fNpoints=0;
   fNfunctions=0;
   fFormulaSize=0;
   fNdim=0;
   if (fFormula) delete [] fFormula;
   fFormula=0;
   fIsSet=0;
   if (fFixedParams) delete [] fFixedParams;
   fFixedParams=0;

   fChisquare=0;
   fY2=0;
   fSpecial=0;
   fRobust=kFALSE;
   fFitsample.Clear();
}

//______________________________________________________________________________
void TLinearFitter::ClearPoints()
{
   //To be used when different sets of points are fitted with the same formula.

   fDesign.Zero();
   fAtb.Zero();
   fDesignTemp.Zero();
   fDesignTemp2.Zero();
   fDesignTemp3.Zero();
   fAtbTemp.Zero();
   fAtbTemp2.Zero();
   fAtbTemp3.Zero();

   fParams.Zero();
   fParCovar.Zero();
   fTValues.Zero();
   fParSign.Zero();

   for (Int_t i=0; i<fNfunctions; i++)
      fFixedParams[i]=0;
   fChisquare=0;
   fNpoints=0;

}

//______________________________________________________________________________
void TLinearFitter::Chisquare()
{
   //Calculates the chisquare.

   Int_t i, j;
   Double_t sumtotal2;
   Double_t temp, temp2;

   if (!fStoreData){
      sumtotal2 = 0;
      for (i=0; i<fNfunctions; i++){
         for (j=0; j<i; j++){
            sumtotal2 += 2*fParams(i)*fParams(j)*fDesign(j, i);
         }
         sumtotal2 += fParams(i)*fParams(i)*fDesign(i, i);
         sumtotal2 -= 2*fParams(i)*fAtb(i);
      }
      sumtotal2 += fY2;
   } else {
      sumtotal2 = 0;
      if (fInputFunction){
         for (i=0; i<fNpoints; i++){
            temp = fInputFunction->EvalPar(TMatrixDRow(fX, i).GetPtr());
            temp2 = (fY(i)-temp)*(fY(i)-temp);
            temp2 /= fE(i)*fE(i);
            sumtotal2 += temp2;
         }
      } else {
         sumtotal2 = 0;
         Double_t val[100];
         for (Int_t point=0; point<fNpoints; point++){
            temp = 0;
            if ((fSpecial>100)&&(fSpecial<200)){
               Int_t npar = fSpecial-100;
               val[0] = 1;
               for (i=1; i<npar; i++)
                  val[i] = val[i-1]*fX(point, 0);
               for (i=0; i<npar; i++)
                  temp += fParams(i)*val[i];
            } else {
               if (fSpecial>200) {
                  //hyperplane case
                  Int_t npar = fSpecial-201;
                  temp+=fParams(0);
                  for (i=0; i<npar; i++)
                     temp += fParams(i+1)*fX(point, i);
               } else {
                  for (j=0; j<fNfunctions; j++) {
                     TFormula *f1 = (TFormula*)(fFunctions.UncheckedAt(j));
                     val[j] = f1->EvalPar(TMatrixDRow(fX, point).GetPtr());
                     temp += fParams(j)*val[j];
                  }
               }
            }
         temp2 = (fY(point)-temp)*(fY(point)-temp);
         temp2 /= fE(point)*fE(point);
         sumtotal2 += temp2;
         }
      }
   }
   fChisquare = sumtotal2;

}

//______________________________________________________________________________
void TLinearFitter::ComputeTValues()
{
   // Computes parameters' t-values and significance

   for (Int_t i=0; i<fNfunctions; i++){
      fTValues(i) = fParams(i)/(TMath::Sqrt(fParCovar(i, i)));
      fParSign(i) = 2*(1-TMath::StudentI(TMath::Abs(fTValues(i)),fNpoints-fNfunctions+fNfixed));
   }
}

//______________________________________________________________________________
Int_t TLinearFitter::Eval()
{
   // Perform the fit and evaluate the parameters
   // Returns 0 if the fit is ok, 1 if there are errors

   Double_t e;
   if (fFunctions.IsEmpty()&&(!fInputFunction)&&(fSpecial<=200)){
      Error("TLinearFitter::Eval", "The formula hasn't been set");
      return 1;
   }
   //
   fParams.ResizeTo(fNfunctions);
   fTValues.ResizeTo(fNfunctions);
   fParSign.ResizeTo(fNfunctions);
   fParCovar.ResizeTo(fNfunctions,fNfunctions);

   fChisquare=0;

   if (!fIsSet){
      Bool_t update = UpdateMatrix();
      if (!update){
         //no points to fit
         fParams.Zero();
         fParCovar.Zero();
         fTValues.Zero();
         fParSign.Zero();
         fChisquare=0;
         if (fInputFunction){
            fInputFunction->SetParameters(fParams.GetMatrixArray());
            for (Int_t i=0; i<fNfunctions; i++)
               ((TF1*)fInputFunction)->SetParError(i, 0);
            ((TF1*)fInputFunction)->SetChisquare(0);
            ((TF1*)fInputFunction)->SetNDF(0);
            ((TF1*)fInputFunction)->SetNumberFitPoints(0);
         }
         return 1;
      }
   }

   AddTempMatrices();

//fixing fixed parameters, if there are any
   Int_t i, ii, j=0;
   if (fNfixed>0){
      for (ii=0; ii<fNfunctions; ii++)
         fDesignTemp(ii, fNfixed) = fAtb(ii);
      for (i=0; i<fNfunctions; i++){
         if (fFixedParams[i]){
            for (ii=0; ii<i; ii++)
               fDesignTemp(ii, j) = fDesign(ii, i);
            for (ii=i; ii<fNfunctions; ii++)
               fDesignTemp(ii, j) = fDesign(i, ii);
            j++;
            for (ii=0; ii<fNfunctions; ii++){
               fAtb(ii)-=fParams(i)*(fDesignTemp(ii, j-1));
            }
         }
      }
      for (i=0; i<fNfunctions; i++){
         if (fFixedParams[i]){
            for (ii=0; ii<fNfunctions; ii++){
               fDesign(ii, i) = 0;
               fDesign(i, ii) = 0;
            }
            fDesign (i, i) = 1;
            fAtb(i) = fParams(i);
         }
      }
   }

   TDecompChol chol(fDesign);
   Bool_t ok;
   TVectorD coef(fNfunctions);
   coef=chol.Solve(fAtb, ok);
   if (!ok){
      Error("Eval","Matrix inversion failed");
      fParams.Zero();
      fParCovar.Zero();
      fTValues.Zero();
      fParSign.Zero();
      if (fInputFunction){
         fInputFunction->SetParameters(fParams.GetMatrixArray());
         if (fInputFunction->InheritsFrom(TF1::Class())){
            ((TF1*)fInputFunction)->SetChisquare(0);
            ((TF1*)fInputFunction)->SetNDF(fNpoints-fNfunctions+fNfixed);
            ((TF1*)fInputFunction)->SetNumberFitPoints(fNpoints);
         }
      }
      return 1;
   }
   fParams=coef;
   fParCovar=chol.Invert();

   if (fInputFunction){
      fInputFunction->SetParameters(fParams.GetMatrixArray());
      if (fInputFunction->InheritsFrom(TF1::Class())){
         for (i=0; i<fNfunctions; i++){
            e = TMath::Sqrt(fParCovar(i, i));
            ((TF1*)fInputFunction)->SetParError(i, e);
         }
         if (!fObjectFit)
            ((TF1*)fInputFunction)->SetChisquare(GetChisquare());
         ((TF1*)fInputFunction)->SetNDF(fNpoints-fNfunctions+fNfixed);
         ((TF1*)fInputFunction)->SetNumberFitPoints(fNpoints);
         }
   }

   //if parameters were fixed, change the design matrix back as it was before fixing
   j = 0;
   if (fNfixed>0){
      for (i=0; i<fNfunctions; i++){
         if (fFixedParams[i]){
            for (ii=0; ii<i; ii++){
               fDesign(ii, i) = fDesignTemp(ii, j);
               fAtb(ii) = fDesignTemp(ii, fNfixed);
            }
            for (ii=i; ii<fNfunctions; ii++){
               fDesign(i, ii) = fDesignTemp(ii, j);
               fAtb(ii) = fDesignTemp(ii, fNfixed);
            }
            j++;
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
void TLinearFitter::FixParameter(Int_t ipar)
{
   //Fixes paramter #ipar at its current value.

   if (fParams.NonZeros()<1){
      Error("FixParameter", "no value available to fix the parameter");
      return;
   }
   if (ipar>fNfunctions || ipar<0){
      Error("FixParameter", "illegal parameter value");
      return;
   }
   if (fNfixed==fNfunctions) {
      Error("FixParameter", "no free parameters left");
      return;
   }
   if (!fFixedParams)
      fFixedParams = new Bool_t[fNfunctions];
   fFixedParams[ipar] = 1;
   fNfixed++;
}

//______________________________________________________________________________
void TLinearFitter::FixParameter(Int_t ipar, Double_t parvalue)
{
   //Fixes parameter #ipar at value parvalue.

   if (ipar>fNfunctions || ipar<0){
      Error("FixParameter", "illegal parameter value");
      return;
   }
   if (fNfixed==fNfunctions) {
      Error("FixParameter", "no free parameters left");
      return;
   }
   if(!fFixedParams)
      fFixedParams = new Bool_t[fNfunctions];
   fFixedParams[ipar] = 1;
   if (fParams.GetNoElements()<fNfunctions)
      fParams.ResizeTo(fNfunctions);
   fParams(ipar) = parvalue;
   fNfixed++;
}

//______________________________________________________________________________
void TLinearFitter::ReleaseParameter(Int_t ipar)
{
   //Releases parameter #ipar.

   if (ipar>fNfunctions || ipar<0){
      Error("ReleaseParameter", "illegal parameter value");
      return;
   }
   if (!fFixedParams[ipar]){
      Warning("ReleaseParameter","This parameter is not fixed\n");
      return;
   } else {
      fFixedParams[ipar] = 0;
      fNfixed--;
   }
}

//______________________________________________________________________________
void TLinearFitter::GetAtbVector(TVectorD &v)
{
   //Get the Atb vector - a vector, used for internal computations

   if (v.GetNoElements()!=fAtb.GetNoElements())
      v.ResizeTo(fAtb.GetNoElements());
   v = fAtb;
}

//______________________________________________________________________________
Double_t TLinearFitter::GetChisquare()
{
   // Get the Chisquare.

   if (fChisquare > 1e-16)
      return fChisquare;
   else {
      Chisquare();
      return fChisquare;
   }
}

//______________________________________________________________________________
void TLinearFitter::GetConfidenceIntervals(Int_t n, Int_t ndim, const Double_t *x, Double_t *ci, Double_t cl)
{
//Computes point-by-point confidence intervals for the fitted function
//Parameters:
//n - number of points
//ndim - dimensions of points
//x - points, at which to compute the intervals, for ndim > 1
//    should be in order: (x0,y0, x1, y1, ... xn, yn)
//ci - computed intervals are returned in this array
//cl - confidence level, default=0.95
//
//NOTE, that this method can only be used when the fitting function inherits from a TF1,
//so it's not possible when the fitting function was set as a string or as a pure TFormula

   if (fInputFunction){
      Double_t *grad = new Double_t[fNfunctions];
      Double_t *sum_vector = new Double_t[fNfunctions];
      Double_t c=0;
      Int_t df = fNpoints-fNfunctions+fNfixed;
      Double_t t = TMath::StudentQuantile(0.5 + cl/2, df);
      Double_t chidf = TMath::Sqrt(fChisquare/df);

      for (Int_t ipoint=0; ipoint<n; ipoint++){
         c=0;
         ((TF1*)(fInputFunction))->GradientPar(x+ndim*ipoint, grad);
         //multiply the covariance matrix by gradient
         for (Int_t irow=0; irow<fNfunctions; irow++){
            sum_vector[irow]=0;
            for (Int_t icol=0; icol<fNfunctions; icol++){
               sum_vector[irow]+=fParCovar(irow,icol)*grad[icol];
            }
         }
         for (Int_t i=0; i<fNfunctions; i++)
            c+=grad[i]*sum_vector[i];
         c=TMath::Sqrt(c);
         ci[ipoint]=c*t*chidf;
      }

      delete [] grad;
      delete [] sum_vector;
   }
}

//______________________________________________________________________________
void TLinearFitter::GetConfidenceIntervals(TObject *obj, Double_t cl)
{
//Computes confidence intervals at level cl. Default is 0.95
//The TObject parameter can be a TGraphErrors, a TGraph2DErrors or a TH123.
//For Graphs, confidence intervals are computed for each point,
//the value of the graph at that point is set to the function value at that
//point, and the graph y-errors (or z-errors) are set to the value of
//the confidence interval at that point
//For Histograms, confidence intervals are computed for each bin center
//The bin content of this bin is then set to the function value at the bin
//center, and the bin error is set to the confidence interval value.
//Allowed combinations:
//Fitted object               Passed object
//TGraph                      TGraphErrors, TH1
//TGraphErrors, AsymmErrors   TGraphErrors, TH1
//TH1                         TGraphErrors, TH1
//TGraph2D                    TGraph2DErrors, TH2
//TGraph2DErrors              TGraph2DErrors, TH2
//TH2                         TGraph2DErrors, TH2
//TH3                         TH3

   if (!fInputFunction) {
      Error("GetConfidenceIntervals", "The case of fitting not with a TFormula is not yet implemented");
      return;
   }

   //TGraph//////////////////

   if (obj->InheritsFrom(TGraph::Class())) {
      TGraph *gr = (TGraph*)obj;
      if (!gr->GetEY()){
         Error("GetConfidenceIntervals", "A TGraphErrors should be passed instead of a graph");
         return;
      }
      if (fObjectFit->InheritsFrom(TGraph2D::Class())){
         Error("GetConfidenceIntervals", "A TGraph2DErrors should be passed instead of a graph");
         return;
      }
      if (fObjectFit->InheritsFrom(TH1::Class())){
         if (((TH1*)(fObjectFit))->GetDimension()>1){
            Error("GetConfidenceIntervals", "A TGraph2DErrors or a TH23 should be passed instead of a graph");
            return;
         }
      }

      GetConfidenceIntervals(gr->GetN(),1,gr->GetX(), gr->GetEY(), cl);
      for (Int_t i=0; i<gr->GetN(); i++)
         gr->SetPoint(i, gr->GetX()[i], fInputFunction->Eval(gr->GetX()[i]));
   }

   //TGraph2D///////////////
   else if (obj->InheritsFrom(TGraph2D::Class())) {
      TGraph2D *gr2 = (TGraph2D*)obj;
      if (!gr2->GetEZ()){
         Error("GetConfidenceIntervals", "A TGraph2DErrors should be passed instead of a TGraph2D");
         return;
      }
      if (fObjectFit->InheritsFrom(TGraph::Class())){
         Error("GetConfidenceIntervals", "A TGraphErrors should be passed instead of a TGraph2D");
         return;
      }
      if (fObjectFit->InheritsFrom(TH1::Class())){
         if (((TH1*)(fObjectFit))->GetDimension()==1){
            Error("GetConfidenceIntervals", "A TGraphErrors or a TH1 should be passed instead of a graph");
            return;
         }
      }
      Double_t xy[2];
      Int_t np = gr2->GetN();
      Double_t *grad = new Double_t[fNfunctions];
      Double_t *sum_vector = new Double_t[fNfunctions];
      Double_t *x = gr2->GetX();
      Double_t *y = gr2->GetY();
      Double_t t = TMath::StudentQuantile(0.5 + cl/2, ((TF1*)(fInputFunction))->GetNDF());
      Double_t chidf = TMath::Sqrt(fChisquare/((TF1*)(fInputFunction))->GetNDF());
      Double_t c = 0;
      for (Int_t ipoint=0; ipoint<np; ipoint++){
         c=0;
         xy[0]=x[ipoint];
         xy[1]=y[ipoint];
         ((TF1*)(fInputFunction))->GradientPar(xy, grad);
         for (Int_t irow=0; irow<fNfunctions; irow++){
            sum_vector[irow]=0;
            for (Int_t icol=0; icol<fNfunctions; icol++)
               sum_vector[irow]+=fParCovar(irow, icol)*grad[icol];
         }
         for (Int_t i=0; i<fNfunctions; i++)
            c+=grad[i]*sum_vector[i];
         c=TMath::Sqrt(c);
         gr2->SetPoint(ipoint, xy[0], xy[1], fInputFunction->EvalPar(xy));
         gr2->GetEZ()[ipoint]=c*t*chidf;
      }
      delete [] grad;
      delete [] sum_vector;
   }

   //TH1////////////////////////
   else if (obj->InheritsFrom(TH1::Class())) {
      if (fObjectFit->InheritsFrom(TGraph::Class())){
         if (((TH1*)obj)->GetDimension()>1){
            Error("GetConfidenceIntervals", "Fitted graph and passed histogram have different number of dimensions");
            return;
         }
      }
      if (fObjectFit->InheritsFrom(TGraph2D::Class())){
         if (((TH1*)obj)->GetDimension()!=2){
            Error("GetConfidenceIntervals", "Fitted graph and passed histogram have different number of dimensions");
            return;
         }
      }
      if (fObjectFit->InheritsFrom(TH1::Class())){
         if (((TH1*)(fObjectFit))->GetDimension()!=((TH1*)(obj))->GetDimension()){
            Error("GetConfidenceIntervals", "Fitted and passed histograms have different number of dimensions");
            return;
         }
      }


      TH1 *hfit = (TH1*)obj;
      Double_t *grad = new Double_t[fNfunctions];
      Double_t *sum_vector = new Double_t[fNfunctions];
      Double_t x[3];
      Int_t hxfirst = hfit->GetXaxis()->GetFirst();
      Int_t hxlast  = hfit->GetXaxis()->GetLast();
      Int_t hyfirst = hfit->GetYaxis()->GetFirst();
      Int_t hylast  = hfit->GetYaxis()->GetLast();
      Int_t hzfirst = hfit->GetZaxis()->GetFirst();
      Int_t hzlast  = hfit->GetZaxis()->GetLast();

      TAxis *xaxis  = hfit->GetXaxis();
      TAxis *yaxis  = hfit->GetYaxis();
      TAxis *zaxis  = hfit->GetZaxis();
      Double_t t = TMath::StudentQuantile(0.5 + cl/2, ((TF1*)(fInputFunction))->GetNDF());
      Double_t chidf = TMath::Sqrt(fChisquare/((TF1*)(fInputFunction))->GetNDF());
      Double_t c=0;
      for (Int_t binz=hzfirst; binz<=hzlast; binz++){
         x[2]=zaxis->GetBinCenter(binz);
         for (Int_t biny=hyfirst; biny<=hylast; biny++) {
            x[1]=yaxis->GetBinCenter(biny);
            for (Int_t binx=hxfirst; binx<=hxlast; binx++) {
               x[0]=xaxis->GetBinCenter(binx);
               ((TF1*)(fInputFunction))->GradientPar(x, grad);
               c=0;
               for (Int_t irow=0; irow<fNfunctions; irow++){
                  sum_vector[irow]=0;
                  for (Int_t icol=0; icol<fNfunctions; icol++)
                     sum_vector[irow]+=fParCovar(irow, icol)*grad[icol];
               }
               for (Int_t i=0; i<fNfunctions; i++)
                  c+=grad[i]*sum_vector[i];
               c=TMath::Sqrt(c);
               hfit->SetBinContent(binx, biny, binz, fInputFunction->EvalPar(x));
               hfit->SetBinError(binx, biny, binz, c*t*chidf);
            }
         }
      }
      delete [] grad;
      delete [] sum_vector;
   }
   else {
      Error("GetConfidenceIntervals", "This object type is not supported");
      return;
   }
}

//______________________________________________________________________________
Double_t* TLinearFitter::GetCovarianceMatrix() const
{
//Returns covariance matrix

   Double_t *p = const_cast<Double_t*>(fParCovar.GetMatrixArray());
   return p;
}

//______________________________________________________________________________
void TLinearFitter::GetCovarianceMatrix(TMatrixD &matr)
{
//Returns covariance matrix

   if (matr.GetNrows()!=fNfunctions || matr.GetNcols()!=fNfunctions){
      matr.ResizeTo(fNfunctions, fNfunctions);
   }
   matr = fParCovar;
}

//______________________________________________________________________________
void TLinearFitter::GetDesignMatrix(TMatrixD &matr)
{
//Returns the internal design matrix
   if (matr.GetNrows()!=fNfunctions || matr.GetNcols()!=fNfunctions){
      matr.ResizeTo(fNfunctions, fNfunctions);
   }
   matr = fDesign;
}

//______________________________________________________________________________
void TLinearFitter::GetErrors(TVectorD &vpar)
{
//Returns parameter errors

   if (vpar.GetNoElements()!=fNfunctions) {
      vpar.ResizeTo(fNfunctions);
   }
   for (Int_t i=0; i<fNfunctions; i++)
      vpar(i) = TMath::Sqrt(fParCovar(i, i));

}

//______________________________________________________________________________
void TLinearFitter::GetParameters(TVectorD &vpar)
{
//Returns parameter values

   if (vpar.GetNoElements()!=fNfunctions) {
      vpar.ResizeTo(fNfunctions);
   }
   vpar=fParams;
}

//______________________________________________________________________________
Int_t TLinearFitter::GetParameter(Int_t ipar,char* name,Double_t& value,Double_t& /*verr*/,Double_t& /*vlow*/, Double_t& /*vhigh*/) const
{
//Returns the value and the name of the parameter #ipar
//NB: In the calling function the argument name must be set large enough

   if (ipar<0 || ipar>fNfunctions) {
      Error("GetParError", "illegal value of parameter");
      return 0;
   }
   value = fParams(ipar);
   if (fInputFunction)
      strcpy(name, fInputFunction->GetParName(ipar));
   else
      name = 0;
   return 1;
}


//______________________________________________________________________________
Double_t TLinearFitter::GetParError(Int_t ipar) const
{
//Returns the error of parameter #ipar

   if (ipar<0 || ipar>fNfunctions) {
      Error("GetParError", "illegal value of parameter");
      return 0;
   }

   return TMath::Sqrt(fParCovar(ipar, ipar));
}


//______________________________________________________________________________
const char *TLinearFitter::GetParName(Int_t ipar) const
{
//Returns name of parameter #ipar

   if (ipar<0 || ipar>fNfunctions) {
      Error("GetParError", "illegal value of parameter");
      return 0;
   }
   if (fInputFunction)
      return fInputFunction->GetParName(ipar);
   return "";
}

//______________________________________________________________________________
Double_t TLinearFitter::GetParTValue(Int_t ipar)
{
//Returns the t-value for parameter #ipar

   if (ipar<0 || ipar>fNfunctions) {
      Error("GetParTValue", "illegal value of parameter");
      return 0;
   }
   if (!fTValues.NonZeros())
      ComputeTValues();
   return fTValues(ipar);
}

//______________________________________________________________________________
Double_t TLinearFitter::GetParSignificance(Int_t ipar)
{
//Returns the significance of parameter #ipar

   if (ipar<0 || ipar>fNfunctions) {
      Error("GetParSignificance", "illegal value of parameter");
      return 0;
   }
   if (!fParSign.NonZeros())
      ComputeTValues();
   return fParSign(ipar);
}

//______________________________________________________________________________
void TLinearFitter::GetFitSample(TBits &bits)
{
//For robust lts fitting, returns the sample, on which the best fit was based

   if (!fRobust){
      Error("GetFitSample", "there is no fit sample in ordinary least-squares fit");
      return;
   }
   for (Int_t i=0; i<fNpoints; i++)
      bits.SetBitNumber(i, fFitsample.TestBitNumber(i));

}

//______________________________________________________________________________
Int_t TLinearFitter::Merge(TCollection *list)
{
   //Merge objects in list
   if (!list) return -1;
   TIter next(list);
   TLinearFitter *lfit = 0;
   while ((lfit = (TLinearFitter*)next())) {
      if (!lfit->InheritsFrom(TLinearFitter::Class())) {
         Error("Add","Attempt to add object of class: %s to a %s",lfit->ClassName(),this->ClassName());
         return -1;
      }
      Add(lfit);
   }
   return 0;
}
//______________________________________________________________________________
void TLinearFitter::SetBasisFunctions(TObjArray * functions)
{
   //set the basis functions in case the fitting function is not
   // set directly
   // The TLinearFitter will manage and delete the functions contained in the list

   fFunctions = *(functions);
   int size = fFunctions.GetEntries();

   fNfunctions=size;
   //change the size of design matrix
   fDesign.ResizeTo(size, size);
   fAtb.ResizeTo(size);
   fDesignTemp.ResizeTo(size, size);
   fDesignTemp2.ResizeTo(size, size);
   fDesignTemp3.ResizeTo(size, size);
   fAtbTemp.ResizeTo(size);
   fAtbTemp2.ResizeTo(size);
   fAtbTemp3.ResizeTo(size);
   if (fFixedParams)
      delete [] fFixedParams;
   fFixedParams=new Bool_t[size];
   fDesign.Zero();
   fAtb.Zero();
   fDesignTemp.Zero();
   fDesignTemp2.Zero();
   fDesignTemp3.Zero();
   fAtbTemp.Zero();
   fAtbTemp2.Zero();
   fAtbTemp3.Zero();
   fY2Temp=0;
   fY2=0;
   for (int i=0; i<size; i++)
      fFixedParams[i]=0;
   fIsSet=kFALSE;
   fChisquare=0;

}


//______________________________________________________________________________
void TLinearFitter::SetDim(Int_t ndim)
{
   //set the number of dimensions

   fNdim=ndim;
   fY.ResizeTo(ndim+1);
   fX.ResizeTo(ndim+1, ndim);
   fE.ResizeTo(ndim+1);

   fNpoints=0;
   fIsSet=kFALSE;
}

//______________________________________________________________________________
void TLinearFitter::SetFormula(const char *formula)
{
  //Additive parts should be separated by "++".
  //Examples (ai are parameters to fit):
  //1.fitting function: a0*x0 + a1*x1 + a2*x2
  //  input formula "x[0]++x[1]++x[2]"
  //2.TMath functions can be used:
  //  fitting function: a0*TMath::Gaus(x, 0, 1) + a1*y
  //  input formula:    "TMath::Gaus(x, 0, 1)++y"
  //fills the array of functions

   Int_t size, special = 0;
   Int_t i;
   //Int_t len = strlen(formula);
   if (fInputFunction)
      fInputFunction = 0;
   fFormulaSize = strlen(formula);
   fFormula = new char[fFormulaSize+1];
   strlcpy(fFormula, formula,fFormulaSize+1);
   fSpecial = 0;
   //in case of a hyperplane:
   char *fstring;
   fstring = (char *)strstr(fFormula, "hyp");
   if (fstring!=0){
      // isHyper = kTRUE;
      fstring+=3;
      sscanf(fstring, "%d", &size);
      //+1 for the constant term
      size++;
      fSpecial=200+size;
   }

   if (fSpecial==0) {
      //in case it's not a hyperplane
      TString sstring(fFormula);
      sstring = sstring.ReplaceAll("++", 2, "|", 1);
      TString replaceformula;

      //count the number of functions

      TObjArray *oa = sstring.Tokenize("|");

      //change the size of functions array and clear it
      if (!fFunctions.IsEmpty())
         fFunctions.Clear();

      fNfunctions = oa->GetEntriesFast();
      fFunctions.Expand(fNfunctions);

      //check if the old notation of xi is used somewhere instead of x[i]
      char pattern[5];
      char replacement[6];
      for (i=0; i<fNdim; i++){
         snprintf(pattern,5, "x%d", i);
         snprintf(replacement,6, "x[%d]", i);
         sstring = sstring.ReplaceAll(pattern, Int_t(i/10)+2, replacement, Int_t(i/10)+4);
      }

      //fill the array of functions
      oa = sstring.Tokenize("|");
      for (i=0; i<fNfunctions; i++) {
         replaceformula = ((TObjString *)oa->UncheckedAt(i))->GetString();
         TFormula *f = new TFormula("f", replaceformula.Data());
         if (!f) {
            Error("TLinearFitter", "f_linear not allocated");
            return;
         }
         special=f->GetNumber();
         fFunctions.Add(f);
      }

      if ((fNfunctions==1)&&(special>299)&&(special<310)){
         //if fitting a polynomial
         size=special-299;
         fSpecial=100+size;
      } else
         size=fNfunctions;
      oa->Delete();
      delete oa;
   }
   fNfunctions=size;
   //change the size of design matrix
   fDesign.ResizeTo(size, size);
   fAtb.ResizeTo(size);
   fDesignTemp.ResizeTo(size, size);
   fDesignTemp2.ResizeTo(size, size);
   fDesignTemp3.ResizeTo(size, size);
   fAtbTemp.ResizeTo(size);
   fAtbTemp2.ResizeTo(size);
   fAtbTemp3.ResizeTo(size);
   if (fFixedParams)
      delete [] fFixedParams;
   fFixedParams=new Bool_t[size];
   fDesign.Zero();
   fAtb.Zero();
   fDesignTemp.Zero();
   fDesignTemp2.Zero();
   fDesignTemp3.Zero();
   fAtbTemp.Zero();
   fAtbTemp2.Zero();
   fAtbTemp3.Zero();
   fY2Temp=0;
   fY2=0;
   for (i=0; i<size; i++)
      fFixedParams[i]=0;
   fIsSet=kFALSE;
   fChisquare=0;

}

//______________________________________________________________________________
void TLinearFitter::SetFormula(TFormula *function)
{
   //Set the fitting function.

   Int_t special, size;
   fInputFunction=function;
   fNfunctions=fInputFunction->GetNpar();
   fSpecial = 0;
   special=fInputFunction->GetNumber();
   if (!fFunctions.IsEmpty())
      fFunctions.Delete();

   if ((special>299)&&(special<310)){
      //if fitting a polynomial
      size=special-299;
      fSpecial=100+size;
   } else
      size=fNfunctions;

   fNfunctions=size;
   //change the size of design matrix
   fDesign.ResizeTo(size, size);
   fAtb.ResizeTo(size);
   fDesignTemp.ResizeTo(size, size);
   fAtbTemp.ResizeTo(size);

   fDesignTemp2.ResizeTo(size, size);
   fDesignTemp3.ResizeTo(size, size);

   fAtbTemp2.ResizeTo(size);
   fAtbTemp3.ResizeTo(size);
   //
   if (fFixedParams)
      delete [] fFixedParams;
   fFixedParams=new Bool_t[size];
   fDesign.Zero();
   fAtb.Zero();
   fDesignTemp.Zero();
   fAtbTemp.Zero();

   fDesignTemp2.Zero();
   fDesignTemp3.Zero();

   fAtbTemp2.Zero();
   fAtbTemp3.Zero();
   fY2Temp=0;
   fY2=0;
   for (Int_t i=0; i<size; i++)
      fFixedParams[i]=0;
   //check if any parameters are fixed (not for pure TFormula)

   if (function->InheritsFrom(TF1::Class())){
      Double_t al,bl;
      for (Int_t i=0;i<fNfunctions;i++) {
         ((TF1*)function)->GetParLimits(i,al,bl);
         if (al*bl !=0 && al >= bl) {
            FixParameter(i, function->GetParameter(i));
         }
      }
   }

   fIsSet=kFALSE;
   fChisquare=0;

}

//______________________________________________________________________________
Bool_t TLinearFitter::UpdateMatrix()
{
   //Update the design matrix after the formula has been changed.

   if (fStoreData) {
      for (Int_t i=0; i<fNpoints; i++) {
         AddToDesign(TMatrixDRow(fX, i).GetPtr(), fY(i), fE(i));
      }
      return 1;
   } else
      return 0;

}

//______________________________________________________________________________
Int_t TLinearFitter::ExecuteCommand(const char *command, Double_t *args, Int_t /*nargs*/)
{
   //To use in TGraph::Fit and TH1::Fit().

   if (!strcmp(command, "FitGraph")){
      if (args)      return GraphLinearFitter(args[0]);
      else           return GraphLinearFitter(0);
   }
   if (!strcmp(command, "FitGraph2D")){
      if (args)      return Graph2DLinearFitter(args[0]);
      else           return Graph2DLinearFitter(0);
   }
   if (!strcmp(command, "FitMultiGraph")){
      if (args)     return  MultiGraphLinearFitter(args[0]);
      else          return  MultiGraphLinearFitter(0);
   }
   if (!strcmp(command, "FitHist"))       return HistLinearFitter();
//   if (!strcmp(command, "FitMultiGraph")) MultiGraphLinearFitter();

   return 0;
}

//______________________________________________________________________________
void TLinearFitter::PrintResults(Int_t level, Double_t /*amin*/) const
{
   // Level = 3 (to be consistent with minuit)  prints parameters and parameter
   // errors.

   if (level==3){
      if (!fRobust){
         printf("Fitting results:\nParameters:\nNO.\t\tVALUE\t\tERROR\n");
         for (Int_t i=0; i<fNfunctions; i++){
            printf("%d\t%e\t%e\n", i, fParams(i), TMath::Sqrt(fParCovar(i, i)));
         }
      } else {
         printf("Fitting results:\nParameters:\nNO.\t\tVALUE\n");
         for (Int_t i=0; i<fNfunctions; i++){
            printf("%d\t%e\n", i, fParams(i));
         }
      }
   }
}

//______________________________________________________________________________
Int_t TLinearFitter::GraphLinearFitter(Double_t h)
{
   //Used in TGraph::Fit().

   StoreData(kFALSE);
   TGraph *grr=(TGraph*)GetObjectFit();
   TF1 *f1=(TF1*)GetUserFunc();
   Foption_t fitOption=GetFitOption();

   //Int_t np=0;
   Double_t *x=grr->GetX();
   Double_t *y=grr->GetY();
   Double_t e;

   Int_t fitResult = 0;
   //set the fitting formula
   SetDim(1);
   SetFormula(f1);

   if (fitOption.Robust){
      fRobust=kTRUE;
      StoreData(kTRUE);
   }
   //put the points into the fitter
   Int_t n=grr->GetN();
   for (Int_t i=0; i<n; i++){
      if (!f1->IsInside(&x[i])) continue;
      e=grr->GetErrorY(i);
      if (e<0 || fitOption.W1)
         e=1;
      AddPoint(&x[i], y[i], e);
   }

   if (fitOption.Robust){
      return EvalRobust(h);
   }

   fitResult = Eval();

   //calculate the precise chisquare
   if (!fitResult){
      if (!fitOption.Nochisq){
         Double_t temp, temp2, sumtotal=0;
         for (Int_t i=0; i<n; i++){
            if (!f1->IsInside(&x[i])) continue;
            temp=f1->Eval(x[i]);
            temp2=(y[i]-temp)*(y[i]-temp);
            e=grr->GetErrorY(i);
            if (e<0 || fitOption.W1)
               e=1;
            temp2/=(e*e);

            sumtotal+=temp2;
         }
         fChisquare=sumtotal;
         f1->SetChisquare(fChisquare);
      }
   }
   return fitResult;
}

//______________________________________________________________________________
Int_t TLinearFitter::Graph2DLinearFitter(Double_t h)
{
   //Minimisation function for a TGraph2D
   StoreData(kFALSE);

   TGraph2D *gr=(TGraph2D*)GetObjectFit();
   TF2 *f2=(TF2*)GetUserFunc();

   Foption_t fitOption=GetFitOption();
   Int_t n        = gr->GetN();
   Double_t *gx   = gr->GetX();
   Double_t *gy   = gr->GetY();
   Double_t *gz   = gr->GetZ();
   Double_t x[2];
   Double_t z, e;
   Int_t fitResult=0;
   SetDim(2);
   SetFormula(f2);

   if (fitOption.Robust){
      fRobust=kTRUE;
      StoreData(kTRUE);
   }

   for (Int_t bin=0;bin<n;bin++) {
      x[0] = gx[bin];
      x[1] = gy[bin];
      if (!f2->IsInside(x)) {
         continue;
      }
      z   = gz[bin];
      e=gr->GetErrorZ(bin);
      if (e<0 || fitOption.W1)
         e=1;
      AddPoint(x, z, e);
   }

   if (fitOption.Robust){
      return EvalRobust(h);
   }

   fitResult = Eval();

   if (!fitResult){
      if (!fitOption.Nochisq){
         //calculate the precise chisquare
         Double_t temp, temp2, sumtotal=0;
         for (Int_t bin=0; bin<n; bin++){
            x[0] = gx[bin];
            x[1] = gy[bin];
            if (!f2->IsInside(x)) {
               continue;
            }
            z   = gz[bin];

            temp=f2->Eval(x[0], x[1]);
            temp2=(z-temp)*(z-temp);
            e=gr->GetErrorZ(bin);
            if (e<0 || fitOption.W1)
               e=1;
            temp2/=(e*e);

            sumtotal+=temp2;
         }
         fChisquare=sumtotal;
         f2->SetChisquare(fChisquare);
      }
   }
   return fitResult;
}

//______________________________________________________________________________
Int_t TLinearFitter::MultiGraphLinearFitter(Double_t h)
{
   //Minimisation function for a TMultiGraph
   Int_t n, i;
   Double_t *gx, *gy;
   Double_t e;
   TVirtualFitter *grFitter = TVirtualFitter::GetFitter();
   TMultiGraph *mg     = (TMultiGraph*)grFitter->GetObjectFit();
   TF1 *f1   = (TF1*)grFitter->GetUserFunc();
   Foption_t fitOption = grFitter->GetFitOption();
   Int_t fitResult=0;
   SetDim(1);

   if (fitOption.Robust){
      fRobust=kTRUE;
      StoreData(kTRUE);
   }
   SetFormula(f1);

   TGraph *gr;
   TIter next(mg->GetListOfGraphs());
   while ((gr = (TGraph*) next())) {
      n        = gr->GetN();
      gx   = gr->GetX();
      gy   = gr->GetY();
      for (i=0; i<n; i++){
         if (!f1->IsInside(&gx[i])) continue;
         e=gr->GetErrorY(i);
         if (e<0 || fitOption.W1)
            e=1;
         AddPoint(&gx[i], gy[i], e);
      }
   }

   if (fitOption.Robust){
      return EvalRobust(h);
   }

   fitResult = Eval();

   //calculate the chisquare
   if (!fitResult){
      if (!fitOption.Nochisq){
         Double_t temp, temp2, sumtotal=0;
         next.Reset();
         while((gr = (TGraph*)next())) {
            n        = gr->GetN();
            gx   = gr->GetX();
            gy   = gr->GetY();
            for (i=0; i<n; i++){
               if (!f1->IsInside(&gx[i])) continue;
               temp=f1->Eval(gx[i]);
               temp2=(gy[i]-temp)*(gy[i]-temp);
               e=gr->GetErrorY(i);
               if (e<0 || fitOption.W1)
                  e=1;
               temp2/=(e*e);

               sumtotal+=temp2;
            }

         }
         fChisquare=sumtotal;
         f1->SetChisquare(fChisquare);
      }
   }
   return fitResult;
}

//______________________________________________________________________________
Int_t TLinearFitter::HistLinearFitter()
{
   // Minimization function for H1s using a Chisquare method.

   StoreData(kFALSE);
   Double_t cu,eu;
   // Double_t dersum[100], grad[100];
   Double_t x[3];
   Int_t bin,binx,biny,binz;
   //   Axis_t binlow, binup, binsize;

   TH1 *hfit = (TH1*)GetObjectFit();
   TF1 *f1   = (TF1*)GetUserFunc();
   Int_t fitResult;
   Foption_t fitOption = GetFitOption();
   //SetDim(hfit->GetDimension());
   SetDim(f1->GetNdim());
   SetFormula(f1);

   Int_t hxfirst = GetXfirst();
   Int_t hxlast  = GetXlast();
   Int_t hyfirst = GetYfirst();
   Int_t hylast  = GetYlast();
   Int_t hzfirst = GetZfirst();
   Int_t hzlast  = GetZlast();
   TAxis *xaxis  = hfit->GetXaxis();
   TAxis *yaxis  = hfit->GetYaxis();
   TAxis *zaxis  = hfit->GetZaxis();

   for (binz=hzfirst;binz<=hzlast;binz++) {
      x[2]  = zaxis->GetBinCenter(binz);
      for (biny=hyfirst;biny<=hylast;biny++) {
         x[1]  = yaxis->GetBinCenter(biny);
         for (binx=hxfirst;binx<=hxlast;binx++) {
            x[0]  = xaxis->GetBinCenter(binx);
            if (!f1->IsInside(x)) continue;
            bin = hfit->GetBin(binx,biny,binz);
            cu  = hfit->GetBinContent(bin);
            if (f1->GetNdim() < hfit->GetDimension()) {
               if (hfit->GetDimension() > 2) cu = x[2];
               else                          cu = x[1];
            }
            if (fitOption.W1) {
               if (fitOption.W1==1 && cu == 0) continue;
               eu = 1;
            } else {
               eu  = hfit->GetBinError(bin);
               if (eu <= 0) continue;
            }
            AddPoint(x, cu, eu);
         }
      }
   }

   fitResult = Eval();

   if (!fitResult){
      if (!fitOption.Nochisq){
         Double_t temp, temp2, sumtotal=0;
         for (binz=hzfirst;binz<=hzlast;binz++) {
            x[2]  = zaxis->GetBinCenter(binz);
            for (biny=hyfirst;biny<=hylast;biny++) {
               x[1]  = yaxis->GetBinCenter(biny);
               for (binx=hxfirst;binx<=hxlast;binx++) {
                  x[0]  = xaxis->GetBinCenter(binx);
                  if (!f1->IsInside(x)) continue;
                  bin = hfit->GetBin(binx,biny,binz);
                  cu  = hfit->GetBinContent(bin);

                  if (fitOption.W1) {
                     if (fitOption.W1==1 && cu == 0) continue;
                     eu = 1;
                  } else {
                     eu  = hfit->GetBinError(bin);
                     if (eu <= 0) continue;
                  }
                  temp=f1->EvalPar(x);
                  temp2=(cu-temp)*(cu-temp);
                  temp2/=(eu*eu);
                  sumtotal+=temp2;
               }
            }
         }

         fChisquare=sumtotal;
         f1->SetChisquare(fChisquare);
      }
   }
   return fitResult;
}

//____________________________________________________________________________
void TLinearFitter::Streamer(TBuffer &R__b)
{
   if (R__b.IsReading()) {
      Int_t old_matr_size = fNfunctions;
      R__b.ReadClassBuffer(TLinearFitter::Class(),this);
      if (old_matr_size < fNfunctions) {
         fDesignTemp.ResizeTo(fNfunctions, fNfunctions);
         fAtbTemp.ResizeTo(fNfunctions);

         fDesignTemp2.ResizeTo(fNfunctions, fNfunctions);
         fDesignTemp3.ResizeTo(fNfunctions, fNfunctions);

         fAtbTemp2.ResizeTo(fNfunctions);
         fAtbTemp3.ResizeTo(fNfunctions);
      }
   } else {
      if (fAtb.NonZeros()==0) AddTempMatrices();
      R__b.WriteClassBuffer(TLinearFitter::Class(),this);
   }
}

//______________________________________________________________________________
Int_t TLinearFitter::EvalRobust(Double_t h)
{
   //Finds the parameters of the fitted function in case data contains
   //outliers.
   //Parameter h stands for the minimal fraction of good points in the
   //dataset (h < 1, i.e. for 70% of good points take h=0.7).
   //The default value of h*Npoints is  (Npoints + Nparameters+1)/2
   //If the user provides a value of h smaller than above, default is taken
   //See class description for the algorithm details

   fRobust = kTRUE;
   Double_t kEps = 1e-13;
   Int_t nmini = 300;
   Int_t i, j, maxind=0, k, k1 = 500;
   Int_t nbest = 10;
   Double_t chi2 = -1;

   if (fFunctions.IsEmpty()&&(!fInputFunction)&&(fSpecial<=200)){
      Error("TLinearFitter::EvalRobust", "The formula hasn't been set");
      return 1;
   }


   Double_t *bestchi2 = new Double_t[nbest];
   for (i=0; i<nbest; i++)
      bestchi2[i]=1e30;

   Int_t hdef=Int_t((fNpoints+fNfunctions+1)/2);

   if (h>0.000001 && h<1 && fNpoints*h > hdef)
      fH = Int_t(fNpoints*h);
   else {
      // print message only when h is not zero
      if (h>0) Warning("Fitting:", "illegal value of H, default is taken, h = %3.2f",double(hdef)/fNpoints);
      fH=hdef;
   }

   fDesign.ResizeTo(fNfunctions, fNfunctions);
   fAtb.ResizeTo(fNfunctions);
   fParams.ResizeTo(fNfunctions);

   Int_t *index = new Int_t[fNpoints];
   Double_t *residuals = new Double_t[fNpoints];

   if (fNpoints < 2*nmini) {
      //when number of cases is small

      //to store the best coefficients (columnwise)
      TMatrixD cstock(fNfunctions, nbest);
      for (k = 0; k < k1; k++) {
         CreateSubset(fNpoints, fH, index);
         chi2 = CStep(1, fH, residuals,index, index, -1, -1);
         chi2 = CStep(2, fH, residuals,index, index, -1, -1);
         maxind = TMath::LocMax(nbest, bestchi2);
         if (chi2 < bestchi2[maxind]) {
            bestchi2[maxind] = chi2;
            for (i=0; i<fNfunctions; i++)
               cstock(i, maxind) = fParams(i);
         }
      }

      //for the nbest best results, perform CSteps until convergence
      Int_t *bestindex = new Int_t[fH];
      Double_t currentbest;
      for (i=0; i<nbest; i++) {
         for (j=0; j<fNfunctions; j++)
            fParams(j) = cstock(j, i);
         chi2 = 1;
         while (chi2 > kEps) {
            chi2 = CStep(2, fH, residuals,index, index, -1, -1);
            if (TMath::Abs(chi2 - bestchi2[i]) < kEps)
               break;
            else
               bestchi2[i] = chi2;
         }
         currentbest = TMath::MinElement(nbest, bestchi2);
         if (chi2 <= currentbest + kEps) {
            for (j=0; j<fH; j++){
               bestindex[j]=index[j];
            }
            maxind = i;
         }
         for (j=0; j<fNfunctions; j++)
            cstock(j, i) = fParams(j);
      }
      //report the result with the lowest chisquare
      for (j=0; j<fNfunctions; j++)
         fParams(j) = cstock(j, maxind);
      fFitsample.SetBitNumber(fNpoints, kFALSE);
      for (j=0; j<fH; j++){
         //printf("bestindex[%d]=%d\n", j, bestindex[j]);
         fFitsample.SetBitNumber(bestindex[j]);
      }
      if (fInputFunction && fInputFunction->InheritsFrom(TF1::Class())) {
         ((TF1*)fInputFunction)->SetChisquare(bestchi2[maxind]);
         ((TF1*)fInputFunction)->SetNumberFitPoints(fH);
         ((TF1*)fInputFunction)->SetNDF(fH-fNfunctions);
      }
      delete [] index;
      delete [] bestindex;
      delete [] residuals;
      delete [] bestchi2;
      return 0;
   }
   //if n is large, the dataset should be partitioned
   Int_t indsubdat[5];
   for (i=0; i<5; i++)
      indsubdat[i] = 0;

   Int_t nsub = Partition(nmini, indsubdat);
   Int_t hsub;

   Int_t sum = TMath::Min(nmini*5, fNpoints);

   Int_t *subdat = new Int_t[sum]; //to store the indices of selected cases
   RDraw(subdat, indsubdat);

   TMatrixD cstockbig(fNfunctions, nbest*5);
   Int_t *beststock = new Int_t[nbest];
   Int_t i_start = 0;
   Int_t i_end = indsubdat[0];
   Int_t k2 = Int_t(k1/nsub);
   for (Int_t kgroup = 0; kgroup < nsub; kgroup++) {

      hsub = Int_t(fH * indsubdat[kgroup]/fNpoints);
      for (i=0; i<nbest; i++)
         bestchi2[i] = 1e16;
      for (k=0; k<k2; k++) {
         CreateSubset(indsubdat[kgroup], hsub, index);
         chi2 = CStep(1, hsub, residuals, index, subdat, i_start, i_end);
         chi2 = CStep(2, hsub, residuals, index, subdat, i_start, i_end);
         maxind = TMath::LocMax(nbest, bestchi2);
         if (chi2 < bestchi2[maxind]){
            for (i=0; i<fNfunctions; i++)
               cstockbig(i, nbest*kgroup + maxind) = fParams(i);
            bestchi2[maxind] = chi2;
         }
      }
      if (kgroup != nsub - 1){
         i_start += indsubdat[kgroup];
         i_end += indsubdat[kgroup+1];
      }
   }

   for (i=0; i<nbest; i++)
      bestchi2[i] = 1e30;
   //on the pooled subset
   Int_t hsub2 = Int_t(fH*sum/fNpoints);
   for (k=0; k<nbest*5; k++) {
      for (i=0; i<fNfunctions; i++)
         fParams(i)=cstockbig(i, k);
      chi2 = CStep(1, hsub2, residuals, index, subdat, 0, sum);
      chi2 = CStep(2, hsub2, residuals, index, subdat, 0, sum);
      maxind = TMath::LocMax(nbest, bestchi2);
      if (chi2 < bestchi2[maxind]){
         beststock[maxind] = k;
         bestchi2[maxind] = chi2;
      }
   }

   //now the array beststock keeps indices of 10 best candidates in cstockbig matrix
   for (k=0; k<nbest; k++) {
      for (i=0; i<fNfunctions; i++)
         fParams(i) = cstockbig(i, beststock[k]);
      chi2 = CStep(1, fH, residuals, index, index, -1, -1);
      chi2 = CStep(2, fH, residuals, index, index, -1, -1);
      bestchi2[k] = chi2;
   }

   maxind = TMath::LocMin(nbest, bestchi2);
   for (i=0; i<fNfunctions; i++)
      fParams(i)=cstockbig(i, beststock[maxind]);

   chi2 = 1;
   while (chi2 > kEps) {
      chi2 = CStep(2, fH, residuals, index, index, -1, -1);
      if (TMath::Abs(chi2 - bestchi2[maxind]) < kEps)
         break;
      else
         bestchi2[maxind] = chi2;
   }

   fFitsample.SetBitNumber(fNpoints, kFALSE);
   for (j=0; j<fH; j++)
      fFitsample.SetBitNumber(index[j]);
   if (fInputFunction){
      ((TF1*)fInputFunction)->SetChisquare(bestchi2[maxind]);
      ((TF1*)fInputFunction)->SetNumberFitPoints(fH);
      ((TF1*)fInputFunction)->SetNDF(fH-fNfunctions);
   }

   delete [] subdat;
   delete [] beststock;
   delete [] bestchi2;
   delete [] residuals;
   delete [] index;

   return 0;
}

//____________________________________________________________________________
void TLinearFitter::CreateSubset(Int_t ntotal, Int_t h, Int_t *index)
{
   //Creates a p-subset to start
   //ntotal - total number of points from which the subset is chosen

   Int_t i, j;
   Bool_t repeat=kFALSE;
   Int_t nindex=0;
   Int_t num;
   for(i=0; i<ntotal; i++)
      index[i] = ntotal+1;

   TRandom2 r;
   //create a p-subset
   for (i=0; i<fNfunctions; i++) {
      num=Int_t(r.Uniform(0, 1)*(ntotal-1));
      if (i>0){
         for(j=0; j<=i-1; j++) {
            if(index[j]==num)
               repeat = kTRUE;
         }
      }
      if(repeat==kTRUE) {
         i--;
         repeat = kFALSE;
      } else {
         index[i] = num;
         nindex++;
      }
   }

   //compute the coefficients of a hyperplane through the p-subset
   fDesign.Zero();
   fAtb.Zero();
   for (i=0; i<fNfunctions; i++){
      AddToDesign(TMatrixDRow(fX, index[i]).GetPtr(), fY(index[i]), fE(index[i]));
   }
   Bool_t ok;

   ok = Linf();

   //if the chosen points don't define a hyperplane, add more
   while (!ok && (nindex < h)) {
      repeat=kFALSE;
      do{
         num=Int_t(r.Uniform(0,1)*(ntotal-1));
         repeat=kFALSE;
         for(i=0; i<nindex; i++) {
            if(index[i]==num) {
               repeat=kTRUE;
               break;
            }
         }
      } while(repeat==kTRUE);

      index[nindex] = num;
      nindex++;
      //check if the system is of full rank now
      AddToDesign(TMatrixDRow(fX, index[nindex-1]).GetPtr(), fY(index[nindex-1]), fE(index[nindex-1]));
      ok = Linf();
   }
}

//____________________________________________________________________________
Double_t TLinearFitter::CStep(Int_t step, Int_t h, Double_t *residuals, Int_t *index, Int_t *subdat, Int_t start, Int_t end)
{
   //The CStep procedure, as described in the article

   R__ASSERT( !fFunctions.IsEmpty() || fInputFunction ||  fSpecial>200);

   Int_t i, j, itemp, n;
   Double_t func;
   Double_t val[100];
   Int_t npar;
   if (start > -1) {
      n = end - start;
      for (i=0; i<n; i++) {
         func = 0;
         itemp = subdat[start+i];
         if (fInputFunction){
            fInputFunction->SetParameters(fParams.GetMatrixArray());
            func=fInputFunction->EvalPar(TMatrixDRow(fX, itemp).GetPtr());
         } else {
            func=0;
            if ((fSpecial>100)&&(fSpecial<200)){
                  npar = fSpecial-100;
                  val[0] = 1;
                  for (j=1; j<npar; j++)
                     val[j] = val[j-1]*fX(itemp, 0);
                  for (j=0; j<npar; j++)
                     func += fParams(j)*val[j];
            } else if (fSpecial>200) {
               //hyperplane case
               npar = fSpecial-201;
               func+=fParams(0);
               for (j=0; j<npar; j++)
                  func += fParams(j+1)*fX(itemp, j);
            } else {
               // general case
               for (j=0; j<fNfunctions; j++) {
                  TF1 *f1 = (TF1*)(fFunctions.UncheckedAt(j));
                  val[j] = f1->EvalPar(TMatrixDRow(fX, itemp).GetPtr());
                  func += fParams(j)*val[j];
               }
            }
         }
         residuals[i] = (fY(itemp) - func)*(fY(itemp) - func)/(fE(i)*fE(i));
      }
   } else {
      n=fNpoints;
      for (i=0; i<fNpoints; i++) {
         func = 0;
         if (fInputFunction){
            fInputFunction->SetParameters(fParams.GetMatrixArray());
            func=fInputFunction->EvalPar(TMatrixDRow(fX, i).GetPtr());
         } else {
            func=0;
            if ((fSpecial>100)&&(fSpecial<200)){
               npar = fSpecial-100;
               val[0] = 1;
               for (j=1; j<npar; j++)
                  val[j] = val[j-1]*fX(i, 0);
               for (j=0; j<npar; j++)
                  func += fParams(j)*val[j];
            } else if (fSpecial>200) {
               //hyperplane case
               npar = fSpecial-201;
               func+=fParams(0);
               for (j=0; j<npar; j++)
                  func += fParams(j+1)*fX(i, j);
            } else {
               for (j=0; j<fNfunctions; j++) {
                  TF1 *f1 = (TF1*)(fFunctions.UncheckedAt(j));
                  val[j] = f1->EvalPar(TMatrixDRow(fX, i).GetPtr());
                  func += fParams(j)*val[j];
               }
            }
         }
         residuals[i] = (fY(i) - func)*(fY(i) - func)/(fE(i)*fE(i));
      }
   }
   //take h with smallest residuals
   TMath::KOrdStat(n, residuals, h-1, index);
   //add them to the design matrix
   fDesign.Zero();
   fAtb.Zero();
   for (i=0; i<h; i++)
      AddToDesign(TMatrixDRow(fX, index[i]).GetPtr(), fY(index[i]), fE(index[i]));

   Linf();

   //don't calculate the chisquare at the 1st cstep
   if (step==1) return 0;
   Double_t sum=0;


   if (start > -1) {
      for (i=0; i<h; i++) {
         itemp = subdat[start+index[i]];
         if (fInputFunction){
            fInputFunction->SetParameters(fParams.GetMatrixArray());
            func=fInputFunction->EvalPar(TMatrixDRow(fX, itemp).GetPtr());
         } else {
            func=0;
            if ((fSpecial>100)&&(fSpecial<200)){
                  npar = fSpecial-100;
                  val[0] = 1;
                  for (j=1; j<npar; j++)
                     val[j] = val[j-1]*fX(itemp, 0);
                  for (j=0; j<npar; j++)
                     func += fParams(j)*val[j];
            } else if (fSpecial>200) {
               //hyperplane case
               npar = fSpecial-201;
               func+=fParams(0);
               for (j=0; j<npar; j++)
                  func += fParams(j+1)*fX(itemp, j);
            } else {
               for (j=0; j<fNfunctions; j++) {
                  TF1 *f1 = (TF1*)(fFunctions.UncheckedAt(j));
                  val[j] = f1->EvalPar(TMatrixDRow(fX, itemp).GetPtr());
                  func += fParams(j)*val[j];
               }
            }
         }
         sum+=(fY(itemp)-func)*(fY(itemp)-func)/(fE(itemp)*fE(itemp));
      }
   } else {
      for (i=0; i<h; i++) {
         if (fInputFunction){
            fInputFunction->SetParameters(fParams.GetMatrixArray());
            func=fInputFunction->EvalPar(TMatrixDRow(fX, index[i]).GetPtr());
         } else {
            func=0;
            if ((fSpecial>100)&&(fSpecial<200)){
               npar = fSpecial-100;
               val[0] = 1;
               for (j=1; j<npar; j++)
                  val[j] = val[j-1]*fX(index[i], 0);
               for (j=0; j<npar; j++)
                  func += fParams(j)*val[j];
            } else {
               if (fSpecial>200) {
                  //hyperplane case
                  npar = fSpecial-201;
                  func+=fParams(0);
                  for (j=0; j<npar; j++)
                     func += fParams(j+1)*fX(index[i], j);
               } else {
                  for (j=0; j<fNfunctions; j++) {
                     TF1 *f1 = (TF1*)(fFunctions.UncheckedAt(j));
                     val[j] = f1->EvalPar(TMatrixDRow(fX, index[i]).GetPtr());
                     func += fParams(j)*val[j];
                  }
               }
            }
         }

         sum+=(fY(index[i])-func)*(fY(index[i])-func)/(fE(index[i])*fE(index[i]));
      }
   }

   return sum;
}

//____________________________________________________________________________
Bool_t TLinearFitter::Linf()
{

   //currently without the intercept term
   fDesignTemp2+=fDesignTemp3;
   fDesignTemp+=fDesignTemp2;
   fDesign+=fDesignTemp;
   fDesignTemp3.Zero();
   fDesignTemp2.Zero();
   fDesignTemp.Zero();
   fAtbTemp2+=fAtbTemp3;
   fAtbTemp+=fAtbTemp2;
   fAtb+=fAtbTemp;
   fAtbTemp3.Zero();
   fAtbTemp2.Zero();
   fAtbTemp.Zero();

   fY2+=fY2Temp;
   fY2Temp=0;


   TDecompChol chol(fDesign);
   TVectorD temp(fNfunctions);
   Bool_t ok;
   temp = chol.Solve(fAtb, ok);
   if (!ok){
      Error("Linf","Matrix inversion failed");
      //fDesign.Print();
      fParams.Zero();
      return kFALSE;
   }
   fParams = temp;
   return ok;
}

//____________________________________________________________________________
Int_t TLinearFitter::Partition(Int_t nmini, Int_t *indsubdat)
{
   //divides the elements into approximately equal subgroups
   //number of elements in each subgroup is stored in indsubdat
   //number of subgroups is returned

   Int_t nsub;

   if ((fNpoints>=2*nmini) && (fNpoints<=(3*nmini-1))) {
      if (fNpoints%2==1){
         indsubdat[0]=Int_t(fNpoints*0.5);
         indsubdat[1]=Int_t(fNpoints*0.5)+1;
      } else
         indsubdat[0]=indsubdat[1]=Int_t(fNpoints/2);
      nsub=2;
   }
   else{
      if((fNpoints>=3*nmini) && (fNpoints<(4*nmini -1))) {
         if(fNpoints%3==0){
            indsubdat[0]=indsubdat[1]=indsubdat[2]=Int_t(fNpoints/3);
         } else {
            indsubdat[0]=Int_t(fNpoints/3);
            indsubdat[1]=Int_t(fNpoints/3)+1;
            if (fNpoints%3==1) indsubdat[2]=Int_t(fNpoints/3);
            else indsubdat[2]=Int_t(fNpoints/3)+1;
         }
         nsub=3;
      }
      else{
         if((fNpoints>=4*nmini)&&(fNpoints<=(5*nmini-1))){
            if (fNpoints%4==0) indsubdat[0]=indsubdat[1]=indsubdat[2]=indsubdat[3]=Int_t(fNpoints/4);
            else {
               indsubdat[0]=Int_t(fNpoints/4);
               indsubdat[1]=Int_t(fNpoints/4)+1;
               if(fNpoints%4==1) indsubdat[2]=indsubdat[3]=Int_t(fNpoints/4);
               if(fNpoints%4==2) {
                  indsubdat[2]=Int_t(fNpoints/4)+1;
                  indsubdat[3]=Int_t(fNpoints/4);
               }
               if(fNpoints%4==3) indsubdat[2]=indsubdat[3]=Int_t(fNpoints/4)+1;
            }
            nsub=4;
         } else {
            for(Int_t i=0; i<5; i++)
               indsubdat[i]=nmini;
            nsub=5;
         }
      }
   }
   return nsub;
}

//____________________________________________________________________________
void TLinearFitter::RDraw(Int_t *subdat, Int_t *indsubdat)
{
   //Draws ngroup nonoverlapping subdatasets out of a dataset of size n
   //such that the selected case numbers are uniformly distributed from 1 to n

   Int_t jndex = 0;
   Int_t nrand;
   Int_t i, k, m, j;
   Int_t ngroup=0;
   for (i=0; i<5; i++) {
      if (indsubdat[i]!=0)
         ngroup++;
   }
   TRandom r;
   for (k=1; k<=ngroup; k++) {
      for (m=1; m<=indsubdat[k-1]; m++) {
         nrand = Int_t(r.Uniform(0, 1) * (fNpoints-jndex)) + 1;
         jndex++;
         if (jndex==1) {
            subdat[0] = nrand;
         } else {
            subdat[jndex-1] = nrand + jndex - 2;
            for (i=1; i<=jndex-1; i++) {
               if(subdat[i-1] > nrand+i-2) {
                  for(j=jndex; j>=i+1; j--) {
                     subdat[j-1] = subdat[j-2];
                  }
                  subdat[i-1] = nrand+i-2;
                  break;  //breaking the loop for(i=1...
               }
            }
         }
      }
   }
}


 TLinearFitter.cxx:1
 TLinearFitter.cxx:2
 TLinearFitter.cxx:3
 TLinearFitter.cxx:4
 TLinearFitter.cxx:5
 TLinearFitter.cxx:6
 TLinearFitter.cxx:7
 TLinearFitter.cxx:8
 TLinearFitter.cxx:9
 TLinearFitter.cxx:10
 TLinearFitter.cxx:11
 TLinearFitter.cxx:12
 TLinearFitter.cxx:13
 TLinearFitter.cxx:14
 TLinearFitter.cxx:15
 TLinearFitter.cxx:16
 TLinearFitter.cxx:17
 TLinearFitter.cxx:18
 TLinearFitter.cxx:19
 TLinearFitter.cxx:20
 TLinearFitter.cxx:21
 TLinearFitter.cxx:22
 TLinearFitter.cxx:23
 TLinearFitter.cxx:24
 TLinearFitter.cxx:25
 TLinearFitter.cxx:26
 TLinearFitter.cxx:27
 TLinearFitter.cxx:28
 TLinearFitter.cxx:29
 TLinearFitter.cxx:30
 TLinearFitter.cxx:31
 TLinearFitter.cxx:32
 TLinearFitter.cxx:33
 TLinearFitter.cxx:34
 TLinearFitter.cxx:35
 TLinearFitter.cxx:36
 TLinearFitter.cxx:37
 TLinearFitter.cxx:38
 TLinearFitter.cxx:39
 TLinearFitter.cxx:40
 TLinearFitter.cxx:41
 TLinearFitter.cxx:42
 TLinearFitter.cxx:43
 TLinearFitter.cxx:44
 TLinearFitter.cxx:45
 TLinearFitter.cxx:46
 TLinearFitter.cxx:47
 TLinearFitter.cxx:48
 TLinearFitter.cxx:49
 TLinearFitter.cxx:50
 TLinearFitter.cxx:51
 TLinearFitter.cxx:52
 TLinearFitter.cxx:53
 TLinearFitter.cxx:54
 TLinearFitter.cxx:55
 TLinearFitter.cxx:56
 TLinearFitter.cxx:57
 TLinearFitter.cxx:58
 TLinearFitter.cxx:59
 TLinearFitter.cxx:60
 TLinearFitter.cxx:61
 TLinearFitter.cxx:62
 TLinearFitter.cxx:63
 TLinearFitter.cxx:64
 TLinearFitter.cxx:65
 TLinearFitter.cxx:66
 TLinearFitter.cxx:67
 TLinearFitter.cxx:68
 TLinearFitter.cxx:69
 TLinearFitter.cxx:70
 TLinearFitter.cxx:71
 TLinearFitter.cxx:72
 TLinearFitter.cxx:73
 TLinearFitter.cxx:74
 TLinearFitter.cxx:75
 TLinearFitter.cxx:76
 TLinearFitter.cxx:77
 TLinearFitter.cxx:78
 TLinearFitter.cxx:79
 TLinearFitter.cxx:80
 TLinearFitter.cxx:81
 TLinearFitter.cxx:82
 TLinearFitter.cxx:83
 TLinearFitter.cxx:84
 TLinearFitter.cxx:85
 TLinearFitter.cxx:86
 TLinearFitter.cxx:87
 TLinearFitter.cxx:88
 TLinearFitter.cxx:89
 TLinearFitter.cxx:90
 TLinearFitter.cxx:91
 TLinearFitter.cxx:92
 TLinearFitter.cxx:93
 TLinearFitter.cxx:94
 TLinearFitter.cxx:95
 TLinearFitter.cxx:96
 TLinearFitter.cxx:97
 TLinearFitter.cxx:98
 TLinearFitter.cxx:99
 TLinearFitter.cxx:100
 TLinearFitter.cxx:101
 TLinearFitter.cxx:102
 TLinearFitter.cxx:103
 TLinearFitter.cxx:104
 TLinearFitter.cxx:105
 TLinearFitter.cxx:106
 TLinearFitter.cxx:107
 TLinearFitter.cxx:108
 TLinearFitter.cxx:109
 TLinearFitter.cxx:110
 TLinearFitter.cxx:111
 TLinearFitter.cxx:112
 TLinearFitter.cxx:113
 TLinearFitter.cxx:114
 TLinearFitter.cxx:115
 TLinearFitter.cxx:116
 TLinearFitter.cxx:117
 TLinearFitter.cxx:118
 TLinearFitter.cxx:119
 TLinearFitter.cxx:120
 TLinearFitter.cxx:121
 TLinearFitter.cxx:122
 TLinearFitter.cxx:123
 TLinearFitter.cxx:124
 TLinearFitter.cxx:125
 TLinearFitter.cxx:126
 TLinearFitter.cxx:127
 TLinearFitter.cxx:128
 TLinearFitter.cxx:129
 TLinearFitter.cxx:130
 TLinearFitter.cxx:131
 TLinearFitter.cxx:132
 TLinearFitter.cxx:133
 TLinearFitter.cxx:134
 TLinearFitter.cxx:135
 TLinearFitter.cxx:136
 TLinearFitter.cxx:137
 TLinearFitter.cxx:138
 TLinearFitter.cxx:139
 TLinearFitter.cxx:140
 TLinearFitter.cxx:141
 TLinearFitter.cxx:142
 TLinearFitter.cxx:143
 TLinearFitter.cxx:144
 TLinearFitter.cxx:145
 TLinearFitter.cxx:146
 TLinearFitter.cxx:147
 TLinearFitter.cxx:148
 TLinearFitter.cxx:149
 TLinearFitter.cxx:150
 TLinearFitter.cxx:151
 TLinearFitter.cxx:152
 TLinearFitter.cxx:153
 TLinearFitter.cxx:154
 TLinearFitter.cxx:155
 TLinearFitter.cxx:156
 TLinearFitter.cxx:157
 TLinearFitter.cxx:158
 TLinearFitter.cxx:159
 TLinearFitter.cxx:160
 TLinearFitter.cxx:161
 TLinearFitter.cxx:162
 TLinearFitter.cxx:163
 TLinearFitter.cxx:164
 TLinearFitter.cxx:165
 TLinearFitter.cxx:166
 TLinearFitter.cxx:167
 TLinearFitter.cxx:168
 TLinearFitter.cxx:169
 TLinearFitter.cxx:170
 TLinearFitter.cxx:171
 TLinearFitter.cxx:172
 TLinearFitter.cxx:173
 TLinearFitter.cxx:174
 TLinearFitter.cxx:175
 TLinearFitter.cxx:176
 TLinearFitter.cxx:177
 TLinearFitter.cxx:178
 TLinearFitter.cxx:179
 TLinearFitter.cxx:180
 TLinearFitter.cxx:181
 TLinearFitter.cxx:182
 TLinearFitter.cxx:183
 TLinearFitter.cxx:184
 TLinearFitter.cxx:185
 TLinearFitter.cxx:186
 TLinearFitter.cxx:187
 TLinearFitter.cxx:188
 TLinearFitter.cxx:189
 TLinearFitter.cxx:190
 TLinearFitter.cxx:191
 TLinearFitter.cxx:192
 TLinearFitter.cxx:193
 TLinearFitter.cxx:194
 TLinearFitter.cxx:195
 TLinearFitter.cxx:196
 TLinearFitter.cxx:197
 TLinearFitter.cxx:198
 TLinearFitter.cxx:199
 TLinearFitter.cxx:200
 TLinearFitter.cxx:201
 TLinearFitter.cxx:202
 TLinearFitter.cxx:203
 TLinearFitter.cxx:204
 TLinearFitter.cxx:205
 TLinearFitter.cxx:206
 TLinearFitter.cxx:207
 TLinearFitter.cxx:208
 TLinearFitter.cxx:209
 TLinearFitter.cxx:210
 TLinearFitter.cxx:211
 TLinearFitter.cxx:212
 TLinearFitter.cxx:213
 TLinearFitter.cxx:214
 TLinearFitter.cxx:215
 TLinearFitter.cxx:216
 TLinearFitter.cxx:217
 TLinearFitter.cxx:218
 TLinearFitter.cxx:219
 TLinearFitter.cxx:220
 TLinearFitter.cxx:221
 TLinearFitter.cxx:222
 TLinearFitter.cxx:223
 TLinearFitter.cxx:224
 TLinearFitter.cxx:225
 TLinearFitter.cxx:226
 TLinearFitter.cxx:227
 TLinearFitter.cxx:228
 TLinearFitter.cxx:229
 TLinearFitter.cxx:230
 TLinearFitter.cxx:231
 TLinearFitter.cxx:232
 TLinearFitter.cxx:233
 TLinearFitter.cxx:234
 TLinearFitter.cxx:235
 TLinearFitter.cxx:236
 TLinearFitter.cxx:237
 TLinearFitter.cxx:238
 TLinearFitter.cxx:239
 TLinearFitter.cxx:240
 TLinearFitter.cxx:241
 TLinearFitter.cxx:242
 TLinearFitter.cxx:243
 TLinearFitter.cxx:244
 TLinearFitter.cxx:245
 TLinearFitter.cxx:246
 TLinearFitter.cxx:247
 TLinearFitter.cxx:248
 TLinearFitter.cxx:249
 TLinearFitter.cxx:250
 TLinearFitter.cxx:251
 TLinearFitter.cxx:252
 TLinearFitter.cxx:253
 TLinearFitter.cxx:254
 TLinearFitter.cxx:255
 TLinearFitter.cxx:256
 TLinearFitter.cxx:257
 TLinearFitter.cxx:258
 TLinearFitter.cxx:259
 TLinearFitter.cxx:260
 TLinearFitter.cxx:261
 TLinearFitter.cxx:262
 TLinearFitter.cxx:263
 TLinearFitter.cxx:264
 TLinearFitter.cxx:265
 TLinearFitter.cxx:266
 TLinearFitter.cxx:267
 TLinearFitter.cxx:268
 TLinearFitter.cxx:269
 TLinearFitter.cxx:270
 TLinearFitter.cxx:271
 TLinearFitter.cxx:272
 TLinearFitter.cxx:273
 TLinearFitter.cxx:274
 TLinearFitter.cxx:275
 TLinearFitter.cxx:276
 TLinearFitter.cxx:277
 TLinearFitter.cxx:278
 TLinearFitter.cxx:279
 TLinearFitter.cxx:280
 TLinearFitter.cxx:281
 TLinearFitter.cxx:282
 TLinearFitter.cxx:283
 TLinearFitter.cxx:284
 TLinearFitter.cxx:285
 TLinearFitter.cxx:286
 TLinearFitter.cxx:287
 TLinearFitter.cxx:288
 TLinearFitter.cxx:289
 TLinearFitter.cxx:290
 TLinearFitter.cxx:291
 TLinearFitter.cxx:292
 TLinearFitter.cxx:293
 TLinearFitter.cxx:294
 TLinearFitter.cxx:295
 TLinearFitter.cxx:296
 TLinearFitter.cxx:297
 TLinearFitter.cxx:298
 TLinearFitter.cxx:299
 TLinearFitter.cxx:300
 TLinearFitter.cxx:301
 TLinearFitter.cxx:302
 TLinearFitter.cxx:303
 TLinearFitter.cxx:304
 TLinearFitter.cxx:305
 TLinearFitter.cxx:306
 TLinearFitter.cxx:307
 TLinearFitter.cxx:308
 TLinearFitter.cxx:309
 TLinearFitter.cxx:310
 TLinearFitter.cxx:311
 TLinearFitter.cxx:312
 TLinearFitter.cxx:313
 TLinearFitter.cxx:314
 TLinearFitter.cxx:315
 TLinearFitter.cxx:316
 TLinearFitter.cxx:317
 TLinearFitter.cxx:318
 TLinearFitter.cxx:319
 TLinearFitter.cxx:320
 TLinearFitter.cxx:321
 TLinearFitter.cxx:322
 TLinearFitter.cxx:323
 TLinearFitter.cxx:324
 TLinearFitter.cxx:325
 TLinearFitter.cxx:326
 TLinearFitter.cxx:327
 TLinearFitter.cxx:328
 TLinearFitter.cxx:329
 TLinearFitter.cxx:330
 TLinearFitter.cxx:331
 TLinearFitter.cxx:332
 TLinearFitter.cxx:333
 TLinearFitter.cxx:334
 TLinearFitter.cxx:335
 TLinearFitter.cxx:336
 TLinearFitter.cxx:337
 TLinearFitter.cxx:338
 TLinearFitter.cxx:339
 TLinearFitter.cxx:340
 TLinearFitter.cxx:341
 TLinearFitter.cxx:342
 TLinearFitter.cxx:343
 TLinearFitter.cxx:344
 TLinearFitter.cxx:345
 TLinearFitter.cxx:346
 TLinearFitter.cxx:347
 TLinearFitter.cxx:348
 TLinearFitter.cxx:349
 TLinearFitter.cxx:350
 TLinearFitter.cxx:351
 TLinearFitter.cxx:352
 TLinearFitter.cxx:353
 TLinearFitter.cxx:354
 TLinearFitter.cxx:355
 TLinearFitter.cxx:356
 TLinearFitter.cxx:357
 TLinearFitter.cxx:358
 TLinearFitter.cxx:359
 TLinearFitter.cxx:360
 TLinearFitter.cxx:361
 TLinearFitter.cxx:362
 TLinearFitter.cxx:363
 TLinearFitter.cxx:364
 TLinearFitter.cxx:365
 TLinearFitter.cxx:366
 TLinearFitter.cxx:367
 TLinearFitter.cxx:368
 TLinearFitter.cxx:369
 TLinearFitter.cxx:370
 TLinearFitter.cxx:371
 TLinearFitter.cxx:372
 TLinearFitter.cxx:373
 TLinearFitter.cxx:374
 TLinearFitter.cxx:375
 TLinearFitter.cxx:376
 TLinearFitter.cxx:377
 TLinearFitter.cxx:378
 TLinearFitter.cxx:379
 TLinearFitter.cxx:380
 TLinearFitter.cxx:381
 TLinearFitter.cxx:382
 TLinearFitter.cxx:383
 TLinearFitter.cxx:384
 TLinearFitter.cxx:385
 TLinearFitter.cxx:386
 TLinearFitter.cxx:387
 TLinearFitter.cxx:388
 TLinearFitter.cxx:389
 TLinearFitter.cxx:390
 TLinearFitter.cxx:391
 TLinearFitter.cxx:392
 TLinearFitter.cxx:393
 TLinearFitter.cxx:394
 TLinearFitter.cxx:395
 TLinearFitter.cxx:396
 TLinearFitter.cxx:397
 TLinearFitter.cxx:398
 TLinearFitter.cxx:399
 TLinearFitter.cxx:400
 TLinearFitter.cxx:401
 TLinearFitter.cxx:402
 TLinearFitter.cxx:403
 TLinearFitter.cxx:404
 TLinearFitter.cxx:405
 TLinearFitter.cxx:406
 TLinearFitter.cxx:407
 TLinearFitter.cxx:408
 TLinearFitter.cxx:409
 TLinearFitter.cxx:410
 TLinearFitter.cxx:411
 TLinearFitter.cxx:412
 TLinearFitter.cxx:413
 TLinearFitter.cxx:414
 TLinearFitter.cxx:415
 TLinearFitter.cxx:416
 TLinearFitter.cxx:417
 TLinearFitter.cxx:418
 TLinearFitter.cxx:419
 TLinearFitter.cxx:420
 TLinearFitter.cxx:421
 TLinearFitter.cxx:422
 TLinearFitter.cxx:423
 TLinearFitter.cxx:424
 TLinearFitter.cxx:425
 TLinearFitter.cxx:426
 TLinearFitter.cxx:427
 TLinearFitter.cxx:428
 TLinearFitter.cxx:429
 TLinearFitter.cxx:430
 TLinearFitter.cxx:431
 TLinearFitter.cxx:432
 TLinearFitter.cxx:433
 TLinearFitter.cxx:434
 TLinearFitter.cxx:435
 TLinearFitter.cxx:436
 TLinearFitter.cxx:437
 TLinearFitter.cxx:438
 TLinearFitter.cxx:439
 TLinearFitter.cxx:440
 TLinearFitter.cxx:441
 TLinearFitter.cxx:442
 TLinearFitter.cxx:443
 TLinearFitter.cxx:444
 TLinearFitter.cxx:445
 TLinearFitter.cxx:446
 TLinearFitter.cxx:447
 TLinearFitter.cxx:448
 TLinearFitter.cxx:449
 TLinearFitter.cxx:450
 TLinearFitter.cxx:451
 TLinearFitter.cxx:452
 TLinearFitter.cxx:453
 TLinearFitter.cxx:454
 TLinearFitter.cxx:455
 TLinearFitter.cxx:456
 TLinearFitter.cxx:457
 TLinearFitter.cxx:458
 TLinearFitter.cxx:459
 TLinearFitter.cxx:460
 TLinearFitter.cxx:461
 TLinearFitter.cxx:462
 TLinearFitter.cxx:463
 TLinearFitter.cxx:464
 TLinearFitter.cxx:465
 TLinearFitter.cxx:466
 TLinearFitter.cxx:467
 TLinearFitter.cxx:468
 TLinearFitter.cxx:469
 TLinearFitter.cxx:470
 TLinearFitter.cxx:471
 TLinearFitter.cxx:472
 TLinearFitter.cxx:473
 TLinearFitter.cxx:474
 TLinearFitter.cxx:475
 TLinearFitter.cxx:476
 TLinearFitter.cxx:477
 TLinearFitter.cxx:478
 TLinearFitter.cxx:479
 TLinearFitter.cxx:480
 TLinearFitter.cxx:481
 TLinearFitter.cxx:482
 TLinearFitter.cxx:483
 TLinearFitter.cxx:484
 TLinearFitter.cxx:485
 TLinearFitter.cxx:486
 TLinearFitter.cxx:487
 TLinearFitter.cxx:488
 TLinearFitter.cxx:489
 TLinearFitter.cxx:490
 TLinearFitter.cxx:491
 TLinearFitter.cxx:492
 TLinearFitter.cxx:493
 TLinearFitter.cxx:494
 TLinearFitter.cxx:495
 TLinearFitter.cxx:496
 TLinearFitter.cxx:497
 TLinearFitter.cxx:498
 TLinearFitter.cxx:499
 TLinearFitter.cxx:500
 TLinearFitter.cxx:501
 TLinearFitter.cxx:502
 TLinearFitter.cxx:503
 TLinearFitter.cxx:504
 TLinearFitter.cxx:505
 TLinearFitter.cxx:506
 TLinearFitter.cxx:507
 TLinearFitter.cxx:508
 TLinearFitter.cxx:509
 TLinearFitter.cxx:510
 TLinearFitter.cxx:511
 TLinearFitter.cxx:512
 TLinearFitter.cxx:513
 TLinearFitter.cxx:514
 TLinearFitter.cxx:515
 TLinearFitter.cxx:516
 TLinearFitter.cxx:517
 TLinearFitter.cxx:518
 TLinearFitter.cxx:519
 TLinearFitter.cxx:520
 TLinearFitter.cxx:521
 TLinearFitter.cxx:522
 TLinearFitter.cxx:523
 TLinearFitter.cxx:524
 TLinearFitter.cxx:525
 TLinearFitter.cxx:526
 TLinearFitter.cxx:527
 TLinearFitter.cxx:528
 TLinearFitter.cxx:529
 TLinearFitter.cxx:530
 TLinearFitter.cxx:531
 TLinearFitter.cxx:532
 TLinearFitter.cxx:533
 TLinearFitter.cxx:534
 TLinearFitter.cxx:535
 TLinearFitter.cxx:536
 TLinearFitter.cxx:537
 TLinearFitter.cxx:538
 TLinearFitter.cxx:539
 TLinearFitter.cxx:540
 TLinearFitter.cxx:541
 TLinearFitter.cxx:542
 TLinearFitter.cxx:543
 TLinearFitter.cxx:544
 TLinearFitter.cxx:545
 TLinearFitter.cxx:546
 TLinearFitter.cxx:547
 TLinearFitter.cxx:548
 TLinearFitter.cxx:549
 TLinearFitter.cxx:550
 TLinearFitter.cxx:551
 TLinearFitter.cxx:552
 TLinearFitter.cxx:553
 TLinearFitter.cxx:554
 TLinearFitter.cxx:555
 TLinearFitter.cxx:556
 TLinearFitter.cxx:557
 TLinearFitter.cxx:558
 TLinearFitter.cxx:559
 TLinearFitter.cxx:560
 TLinearFitter.cxx:561
 TLinearFitter.cxx:562
 TLinearFitter.cxx:563
 TLinearFitter.cxx:564
 TLinearFitter.cxx:565
 TLinearFitter.cxx:566
 TLinearFitter.cxx:567
 TLinearFitter.cxx:568
 TLinearFitter.cxx:569
 TLinearFitter.cxx:570
 TLinearFitter.cxx:571
 TLinearFitter.cxx:572
 TLinearFitter.cxx:573
 TLinearFitter.cxx:574
 TLinearFitter.cxx:575
 TLinearFitter.cxx:576
 TLinearFitter.cxx:577
 TLinearFitter.cxx:578
 TLinearFitter.cxx:579
 TLinearFitter.cxx:580
 TLinearFitter.cxx:581
 TLinearFitter.cxx:582
 TLinearFitter.cxx:583
 TLinearFitter.cxx:584
 TLinearFitter.cxx:585
 TLinearFitter.cxx:586
 TLinearFitter.cxx:587
 TLinearFitter.cxx:588
 TLinearFitter.cxx:589
 TLinearFitter.cxx:590
 TLinearFitter.cxx:591
 TLinearFitter.cxx:592
 TLinearFitter.cxx:593
 TLinearFitter.cxx:594
 TLinearFitter.cxx:595
 TLinearFitter.cxx:596
 TLinearFitter.cxx:597
 TLinearFitter.cxx:598
 TLinearFitter.cxx:599
 TLinearFitter.cxx:600
 TLinearFitter.cxx:601
 TLinearFitter.cxx:602
 TLinearFitter.cxx:603
 TLinearFitter.cxx:604
 TLinearFitter.cxx:605
 TLinearFitter.cxx:606
 TLinearFitter.cxx:607
 TLinearFitter.cxx:608
 TLinearFitter.cxx:609
 TLinearFitter.cxx:610
 TLinearFitter.cxx:611
 TLinearFitter.cxx:612
 TLinearFitter.cxx:613
 TLinearFitter.cxx:614
 TLinearFitter.cxx:615
 TLinearFitter.cxx:616
 TLinearFitter.cxx:617
 TLinearFitter.cxx:618
 TLinearFitter.cxx:619
 TLinearFitter.cxx:620
 TLinearFitter.cxx:621
 TLinearFitter.cxx:622
 TLinearFitter.cxx:623
 TLinearFitter.cxx:624
 TLinearFitter.cxx:625
 TLinearFitter.cxx:626
 TLinearFitter.cxx:627
 TLinearFitter.cxx:628
 TLinearFitter.cxx:629
 TLinearFitter.cxx:630
 TLinearFitter.cxx:631
 TLinearFitter.cxx:632
 TLinearFitter.cxx:633
 TLinearFitter.cxx:634
 TLinearFitter.cxx:635
 TLinearFitter.cxx:636
 TLinearFitter.cxx:637
 TLinearFitter.cxx:638
 TLinearFitter.cxx:639
 TLinearFitter.cxx:640
 TLinearFitter.cxx:641
 TLinearFitter.cxx:642
 TLinearFitter.cxx:643
 TLinearFitter.cxx:644
 TLinearFitter.cxx:645
 TLinearFitter.cxx:646
 TLinearFitter.cxx:647
 TLinearFitter.cxx:648
 TLinearFitter.cxx:649
 TLinearFitter.cxx:650
 TLinearFitter.cxx:651
 TLinearFitter.cxx:652
 TLinearFitter.cxx:653
 TLinearFitter.cxx:654
 TLinearFitter.cxx:655
 TLinearFitter.cxx:656
 TLinearFitter.cxx:657
 TLinearFitter.cxx:658
 TLinearFitter.cxx:659
 TLinearFitter.cxx:660
 TLinearFitter.cxx:661
 TLinearFitter.cxx:662
 TLinearFitter.cxx:663
 TLinearFitter.cxx:664
 TLinearFitter.cxx:665
 TLinearFitter.cxx:666
 TLinearFitter.cxx:667
 TLinearFitter.cxx:668
 TLinearFitter.cxx:669
 TLinearFitter.cxx:670
 TLinearFitter.cxx:671
 TLinearFitter.cxx:672
 TLinearFitter.cxx:673
 TLinearFitter.cxx:674
 TLinearFitter.cxx:675
 TLinearFitter.cxx:676
 TLinearFitter.cxx:677
 TLinearFitter.cxx:678
 TLinearFitter.cxx:679
 TLinearFitter.cxx:680
 TLinearFitter.cxx:681
 TLinearFitter.cxx:682
 TLinearFitter.cxx:683
 TLinearFitter.cxx:684
 TLinearFitter.cxx:685
 TLinearFitter.cxx:686
 TLinearFitter.cxx:687
 TLinearFitter.cxx:688
 TLinearFitter.cxx:689
 TLinearFitter.cxx:690
 TLinearFitter.cxx:691
 TLinearFitter.cxx:692
 TLinearFitter.cxx:693
 TLinearFitter.cxx:694
 TLinearFitter.cxx:695
 TLinearFitter.cxx:696
 TLinearFitter.cxx:697
 TLinearFitter.cxx:698
 TLinearFitter.cxx:699
 TLinearFitter.cxx:700
 TLinearFitter.cxx:701
 TLinearFitter.cxx:702
 TLinearFitter.cxx:703
 TLinearFitter.cxx:704
 TLinearFitter.cxx:705
 TLinearFitter.cxx:706
 TLinearFitter.cxx:707
 TLinearFitter.cxx:708
 TLinearFitter.cxx:709
 TLinearFitter.cxx:710
 TLinearFitter.cxx:711
 TLinearFitter.cxx:712
 TLinearFitter.cxx:713
 TLinearFitter.cxx:714
 TLinearFitter.cxx:715
 TLinearFitter.cxx:716
 TLinearFitter.cxx:717
 TLinearFitter.cxx:718
 TLinearFitter.cxx:719
 TLinearFitter.cxx:720
 TLinearFitter.cxx:721
 TLinearFitter.cxx:722
 TLinearFitter.cxx:723
 TLinearFitter.cxx:724
 TLinearFitter.cxx:725
 TLinearFitter.cxx:726
 TLinearFitter.cxx:727
 TLinearFitter.cxx:728
 TLinearFitter.cxx:729
 TLinearFitter.cxx:730
 TLinearFitter.cxx:731
 TLinearFitter.cxx:732
 TLinearFitter.cxx:733
 TLinearFitter.cxx:734
 TLinearFitter.cxx:735
 TLinearFitter.cxx:736
 TLinearFitter.cxx:737
 TLinearFitter.cxx:738
 TLinearFitter.cxx:739
 TLinearFitter.cxx:740
 TLinearFitter.cxx:741
 TLinearFitter.cxx:742
 TLinearFitter.cxx:743
 TLinearFitter.cxx:744
 TLinearFitter.cxx:745
 TLinearFitter.cxx:746
 TLinearFitter.cxx:747
 TLinearFitter.cxx:748
 TLinearFitter.cxx:749
 TLinearFitter.cxx:750
 TLinearFitter.cxx:751
 TLinearFitter.cxx:752
 TLinearFitter.cxx:753
 TLinearFitter.cxx:754
 TLinearFitter.cxx:755
 TLinearFitter.cxx:756
 TLinearFitter.cxx:757
 TLinearFitter.cxx:758
 TLinearFitter.cxx:759
 TLinearFitter.cxx:760
 TLinearFitter.cxx:761
 TLinearFitter.cxx:762
 TLinearFitter.cxx:763
 TLinearFitter.cxx:764
 TLinearFitter.cxx:765
 TLinearFitter.cxx:766
 TLinearFitter.cxx:767
 TLinearFitter.cxx:768
 TLinearFitter.cxx:769
 TLinearFitter.cxx:770
 TLinearFitter.cxx:771
 TLinearFitter.cxx:772
 TLinearFitter.cxx:773
 TLinearFitter.cxx:774
 TLinearFitter.cxx:775
 TLinearFitter.cxx:776
 TLinearFitter.cxx:777
 TLinearFitter.cxx:778
 TLinearFitter.cxx:779
 TLinearFitter.cxx:780
 TLinearFitter.cxx:781
 TLinearFitter.cxx:782
 TLinearFitter.cxx:783
 TLinearFitter.cxx:784
 TLinearFitter.cxx:785
 TLinearFitter.cxx:786
 TLinearFitter.cxx:787
 TLinearFitter.cxx:788
 TLinearFitter.cxx:789
 TLinearFitter.cxx:790
 TLinearFitter.cxx:791
 TLinearFitter.cxx:792
 TLinearFitter.cxx:793
 TLinearFitter.cxx:794
 TLinearFitter.cxx:795
 TLinearFitter.cxx:796
 TLinearFitter.cxx:797
 TLinearFitter.cxx:798
 TLinearFitter.cxx:799
 TLinearFitter.cxx:800
 TLinearFitter.cxx:801
 TLinearFitter.cxx:802
 TLinearFitter.cxx:803
 TLinearFitter.cxx:804
 TLinearFitter.cxx:805
 TLinearFitter.cxx:806
 TLinearFitter.cxx:807
 TLinearFitter.cxx:808
 TLinearFitter.cxx:809
 TLinearFitter.cxx:810
 TLinearFitter.cxx:811
 TLinearFitter.cxx:812
 TLinearFitter.cxx:813
 TLinearFitter.cxx:814
 TLinearFitter.cxx:815
 TLinearFitter.cxx:816
 TLinearFitter.cxx:817
 TLinearFitter.cxx:818
 TLinearFitter.cxx:819
 TLinearFitter.cxx:820
 TLinearFitter.cxx:821
 TLinearFitter.cxx:822
 TLinearFitter.cxx:823
 TLinearFitter.cxx:824
 TLinearFitter.cxx:825
 TLinearFitter.cxx:826
 TLinearFitter.cxx:827
 TLinearFitter.cxx:828
 TLinearFitter.cxx:829
 TLinearFitter.cxx:830
 TLinearFitter.cxx:831
 TLinearFitter.cxx:832
 TLinearFitter.cxx:833
 TLinearFitter.cxx:834
 TLinearFitter.cxx:835
 TLinearFitter.cxx:836
 TLinearFitter.cxx:837
 TLinearFitter.cxx:838
 TLinearFitter.cxx:839
 TLinearFitter.cxx:840
 TLinearFitter.cxx:841
 TLinearFitter.cxx:842
 TLinearFitter.cxx:843
 TLinearFitter.cxx:844
 TLinearFitter.cxx:845
 TLinearFitter.cxx:846
 TLinearFitter.cxx:847
 TLinearFitter.cxx:848
 TLinearFitter.cxx:849
 TLinearFitter.cxx:850
 TLinearFitter.cxx:851
 TLinearFitter.cxx:852
 TLinearFitter.cxx:853
 TLinearFitter.cxx:854
 TLinearFitter.cxx:855
 TLinearFitter.cxx:856
 TLinearFitter.cxx:857
 TLinearFitter.cxx:858
 TLinearFitter.cxx:859
 TLinearFitter.cxx:860
 TLinearFitter.cxx:861
 TLinearFitter.cxx:862
 TLinearFitter.cxx:863
 TLinearFitter.cxx:864
 TLinearFitter.cxx:865
 TLinearFitter.cxx:866
 TLinearFitter.cxx:867
 TLinearFitter.cxx:868
 TLinearFitter.cxx:869
 TLinearFitter.cxx:870
 TLinearFitter.cxx:871
 TLinearFitter.cxx:872
 TLinearFitter.cxx:873
 TLinearFitter.cxx:874
 TLinearFitter.cxx:875
 TLinearFitter.cxx:876
 TLinearFitter.cxx:877
 TLinearFitter.cxx:878
 TLinearFitter.cxx:879
 TLinearFitter.cxx:880
 TLinearFitter.cxx:881
 TLinearFitter.cxx:882
 TLinearFitter.cxx:883
 TLinearFitter.cxx:884
 TLinearFitter.cxx:885
 TLinearFitter.cxx:886
 TLinearFitter.cxx:887
 TLinearFitter.cxx:888
 TLinearFitter.cxx:889
 TLinearFitter.cxx:890
 TLinearFitter.cxx:891
 TLinearFitter.cxx:892
 TLinearFitter.cxx:893
 TLinearFitter.cxx:894
 TLinearFitter.cxx:895
 TLinearFitter.cxx:896
 TLinearFitter.cxx:897
 TLinearFitter.cxx:898
 TLinearFitter.cxx:899
 TLinearFitter.cxx:900
 TLinearFitter.cxx:901
 TLinearFitter.cxx:902
 TLinearFitter.cxx:903
 TLinearFitter.cxx:904
 TLinearFitter.cxx:905
 TLinearFitter.cxx:906
 TLinearFitter.cxx:907
 TLinearFitter.cxx:908
 TLinearFitter.cxx:909
 TLinearFitter.cxx:910
 TLinearFitter.cxx:911
 TLinearFitter.cxx:912
 TLinearFitter.cxx:913
 TLinearFitter.cxx:914
 TLinearFitter.cxx:915
 TLinearFitter.cxx:916
 TLinearFitter.cxx:917
 TLinearFitter.cxx:918
 TLinearFitter.cxx:919
 TLinearFitter.cxx:920
 TLinearFitter.cxx:921
 TLinearFitter.cxx:922
 TLinearFitter.cxx:923
 TLinearFitter.cxx:924
 TLinearFitter.cxx:925
 TLinearFitter.cxx:926
 TLinearFitter.cxx:927
 TLinearFitter.cxx:928
 TLinearFitter.cxx:929
 TLinearFitter.cxx:930
 TLinearFitter.cxx:931
 TLinearFitter.cxx:932
 TLinearFitter.cxx:933
 TLinearFitter.cxx:934
 TLinearFitter.cxx:935
 TLinearFitter.cxx:936
 TLinearFitter.cxx:937
 TLinearFitter.cxx:938
 TLinearFitter.cxx:939
 TLinearFitter.cxx:940
 TLinearFitter.cxx:941
 TLinearFitter.cxx:942
 TLinearFitter.cxx:943
 TLinearFitter.cxx:944
 TLinearFitter.cxx:945
 TLinearFitter.cxx:946
 TLinearFitter.cxx:947
 TLinearFitter.cxx:948
 TLinearFitter.cxx:949
 TLinearFitter.cxx:950
 TLinearFitter.cxx:951
 TLinearFitter.cxx:952
 TLinearFitter.cxx:953
 TLinearFitter.cxx:954
 TLinearFitter.cxx:955
 TLinearFitter.cxx:956
 TLinearFitter.cxx:957
 TLinearFitter.cxx:958
 TLinearFitter.cxx:959
 TLinearFitter.cxx:960
 TLinearFitter.cxx:961
 TLinearFitter.cxx:962
 TLinearFitter.cxx:963
 TLinearFitter.cxx:964
 TLinearFitter.cxx:965
 TLinearFitter.cxx:966
 TLinearFitter.cxx:967
 TLinearFitter.cxx:968
 TLinearFitter.cxx:969
 TLinearFitter.cxx:970
 TLinearFitter.cxx:971
 TLinearFitter.cxx:972
 TLinearFitter.cxx:973
 TLinearFitter.cxx:974
 TLinearFitter.cxx:975
 TLinearFitter.cxx:976
 TLinearFitter.cxx:977
 TLinearFitter.cxx:978
 TLinearFitter.cxx:979
 TLinearFitter.cxx:980
 TLinearFitter.cxx:981
 TLinearFitter.cxx:982
 TLinearFitter.cxx:983
 TLinearFitter.cxx:984
 TLinearFitter.cxx:985
 TLinearFitter.cxx:986
 TLinearFitter.cxx:987
 TLinearFitter.cxx:988
 TLinearFitter.cxx:989
 TLinearFitter.cxx:990
 TLinearFitter.cxx:991
 TLinearFitter.cxx:992
 TLinearFitter.cxx:993
 TLinearFitter.cxx:994
 TLinearFitter.cxx:995
 TLinearFitter.cxx:996
 TLinearFitter.cxx:997
 TLinearFitter.cxx:998
 TLinearFitter.cxx:999
 TLinearFitter.cxx:1000
 TLinearFitter.cxx:1001
 TLinearFitter.cxx:1002
 TLinearFitter.cxx:1003
 TLinearFitter.cxx:1004
 TLinearFitter.cxx:1005
 TLinearFitter.cxx:1006
 TLinearFitter.cxx:1007
 TLinearFitter.cxx:1008
 TLinearFitter.cxx:1009
 TLinearFitter.cxx:1010
 TLinearFitter.cxx:1011
 TLinearFitter.cxx:1012
 TLinearFitter.cxx:1013
 TLinearFitter.cxx:1014
 TLinearFitter.cxx:1015
 TLinearFitter.cxx:1016
 TLinearFitter.cxx:1017
 TLinearFitter.cxx:1018
 TLinearFitter.cxx:1019
 TLinearFitter.cxx:1020
 TLinearFitter.cxx:1021
 TLinearFitter.cxx:1022
 TLinearFitter.cxx:1023
 TLinearFitter.cxx:1024
 TLinearFitter.cxx:1025
 TLinearFitter.cxx:1026
 TLinearFitter.cxx:1027
 TLinearFitter.cxx:1028
 TLinearFitter.cxx:1029
 TLinearFitter.cxx:1030
 TLinearFitter.cxx:1031
 TLinearFitter.cxx:1032
 TLinearFitter.cxx:1033
 TLinearFitter.cxx:1034
 TLinearFitter.cxx:1035
 TLinearFitter.cxx:1036
 TLinearFitter.cxx:1037
 TLinearFitter.cxx:1038
 TLinearFitter.cxx:1039
 TLinearFitter.cxx:1040
 TLinearFitter.cxx:1041
 TLinearFitter.cxx:1042
 TLinearFitter.cxx:1043
 TLinearFitter.cxx:1044
 TLinearFitter.cxx:1045
 TLinearFitter.cxx:1046
 TLinearFitter.cxx:1047
 TLinearFitter.cxx:1048
 TLinearFitter.cxx:1049
 TLinearFitter.cxx:1050
 TLinearFitter.cxx:1051
 TLinearFitter.cxx:1052
 TLinearFitter.cxx:1053
 TLinearFitter.cxx:1054
 TLinearFitter.cxx:1055
 TLinearFitter.cxx:1056
 TLinearFitter.cxx:1057
 TLinearFitter.cxx:1058
 TLinearFitter.cxx:1059
 TLinearFitter.cxx:1060
 TLinearFitter.cxx:1061
 TLinearFitter.cxx:1062
 TLinearFitter.cxx:1063
 TLinearFitter.cxx:1064
 TLinearFitter.cxx:1065
 TLinearFitter.cxx:1066
 TLinearFitter.cxx:1067
 TLinearFitter.cxx:1068
 TLinearFitter.cxx:1069
 TLinearFitter.cxx:1070
 TLinearFitter.cxx:1071
 TLinearFitter.cxx:1072
 TLinearFitter.cxx:1073
 TLinearFitter.cxx:1074
 TLinearFitter.cxx:1075
 TLinearFitter.cxx:1076
 TLinearFitter.cxx:1077
 TLinearFitter.cxx:1078
 TLinearFitter.cxx:1079
 TLinearFitter.cxx:1080
 TLinearFitter.cxx:1081
 TLinearFitter.cxx:1082
 TLinearFitter.cxx:1083
 TLinearFitter.cxx:1084
 TLinearFitter.cxx:1085
 TLinearFitter.cxx:1086
 TLinearFitter.cxx:1087
 TLinearFitter.cxx:1088
 TLinearFitter.cxx:1089
 TLinearFitter.cxx:1090
 TLinearFitter.cxx:1091
 TLinearFitter.cxx:1092
 TLinearFitter.cxx:1093
 TLinearFitter.cxx:1094
 TLinearFitter.cxx:1095
 TLinearFitter.cxx:1096
 TLinearFitter.cxx:1097
 TLinearFitter.cxx:1098
 TLinearFitter.cxx:1099
 TLinearFitter.cxx:1100
 TLinearFitter.cxx:1101
 TLinearFitter.cxx:1102
 TLinearFitter.cxx:1103
 TLinearFitter.cxx:1104
 TLinearFitter.cxx:1105
 TLinearFitter.cxx:1106
 TLinearFitter.cxx:1107
 TLinearFitter.cxx:1108
 TLinearFitter.cxx:1109
 TLinearFitter.cxx:1110
 TLinearFitter.cxx:1111
 TLinearFitter.cxx:1112
 TLinearFitter.cxx:1113
 TLinearFitter.cxx:1114
 TLinearFitter.cxx:1115
 TLinearFitter.cxx:1116
 TLinearFitter.cxx:1117
 TLinearFitter.cxx:1118
 TLinearFitter.cxx:1119
 TLinearFitter.cxx:1120
 TLinearFitter.cxx:1121
 TLinearFitter.cxx:1122
 TLinearFitter.cxx:1123
 TLinearFitter.cxx:1124
 TLinearFitter.cxx:1125
 TLinearFitter.cxx:1126
 TLinearFitter.cxx:1127
 TLinearFitter.cxx:1128
 TLinearFitter.cxx:1129
 TLinearFitter.cxx:1130
 TLinearFitter.cxx:1131
 TLinearFitter.cxx:1132
 TLinearFitter.cxx:1133
 TLinearFitter.cxx:1134
 TLinearFitter.cxx:1135
 TLinearFitter.cxx:1136
 TLinearFitter.cxx:1137
 TLinearFitter.cxx:1138
 TLinearFitter.cxx:1139
 TLinearFitter.cxx:1140
 TLinearFitter.cxx:1141
 TLinearFitter.cxx:1142
 TLinearFitter.cxx:1143
 TLinearFitter.cxx:1144
 TLinearFitter.cxx:1145
 TLinearFitter.cxx:1146
 TLinearFitter.cxx:1147
 TLinearFitter.cxx:1148
 TLinearFitter.cxx:1149
 TLinearFitter.cxx:1150
 TLinearFitter.cxx:1151
 TLinearFitter.cxx:1152
 TLinearFitter.cxx:1153
 TLinearFitter.cxx:1154
 TLinearFitter.cxx:1155
 TLinearFitter.cxx:1156
 TLinearFitter.cxx:1157
 TLinearFitter.cxx:1158
 TLinearFitter.cxx:1159
 TLinearFitter.cxx:1160
 TLinearFitter.cxx:1161
 TLinearFitter.cxx:1162
 TLinearFitter.cxx:1163
 TLinearFitter.cxx:1164
 TLinearFitter.cxx:1165
 TLinearFitter.cxx:1166
 TLinearFitter.cxx:1167
 TLinearFitter.cxx:1168
 TLinearFitter.cxx:1169
 TLinearFitter.cxx:1170
 TLinearFitter.cxx:1171
 TLinearFitter.cxx:1172
 TLinearFitter.cxx:1173
 TLinearFitter.cxx:1174
 TLinearFitter.cxx:1175
 TLinearFitter.cxx:1176
 TLinearFitter.cxx:1177
 TLinearFitter.cxx:1178
 TLinearFitter.cxx:1179
 TLinearFitter.cxx:1180
 TLinearFitter.cxx:1181
 TLinearFitter.cxx:1182
 TLinearFitter.cxx:1183
 TLinearFitter.cxx:1184
 TLinearFitter.cxx:1185
 TLinearFitter.cxx:1186
 TLinearFitter.cxx:1187
 TLinearFitter.cxx:1188
 TLinearFitter.cxx:1189
 TLinearFitter.cxx:1190
 TLinearFitter.cxx:1191
 TLinearFitter.cxx:1192
 TLinearFitter.cxx:1193
 TLinearFitter.cxx:1194
 TLinearFitter.cxx:1195
 TLinearFitter.cxx:1196
 TLinearFitter.cxx:1197
 TLinearFitter.cxx:1198
 TLinearFitter.cxx:1199
 TLinearFitter.cxx:1200
 TLinearFitter.cxx:1201
 TLinearFitter.cxx:1202
 TLinearFitter.cxx:1203
 TLinearFitter.cxx:1204
 TLinearFitter.cxx:1205
 TLinearFitter.cxx:1206
 TLinearFitter.cxx:1207
 TLinearFitter.cxx:1208
 TLinearFitter.cxx:1209
 TLinearFitter.cxx:1210
 TLinearFitter.cxx:1211
 TLinearFitter.cxx:1212
 TLinearFitter.cxx:1213
 TLinearFitter.cxx:1214
 TLinearFitter.cxx:1215
 TLinearFitter.cxx:1216
 TLinearFitter.cxx:1217
 TLinearFitter.cxx:1218
 TLinearFitter.cxx:1219
 TLinearFitter.cxx:1220
 TLinearFitter.cxx:1221
 TLinearFitter.cxx:1222
 TLinearFitter.cxx:1223
 TLinearFitter.cxx:1224
 TLinearFitter.cxx:1225
 TLinearFitter.cxx:1226
 TLinearFitter.cxx:1227
 TLinearFitter.cxx:1228
 TLinearFitter.cxx:1229
 TLinearFitter.cxx:1230
 TLinearFitter.cxx:1231
 TLinearFitter.cxx:1232
 TLinearFitter.cxx:1233
 TLinearFitter.cxx:1234
 TLinearFitter.cxx:1235
 TLinearFitter.cxx:1236
 TLinearFitter.cxx:1237
 TLinearFitter.cxx:1238
 TLinearFitter.cxx:1239
 TLinearFitter.cxx:1240
 TLinearFitter.cxx:1241
 TLinearFitter.cxx:1242
 TLinearFitter.cxx:1243
 TLinearFitter.cxx:1244
 TLinearFitter.cxx:1245
 TLinearFitter.cxx:1246
 TLinearFitter.cxx:1247
 TLinearFitter.cxx:1248
 TLinearFitter.cxx:1249
 TLinearFitter.cxx:1250
 TLinearFitter.cxx:1251
 TLinearFitter.cxx:1252
 TLinearFitter.cxx:1253
 TLinearFitter.cxx:1254
 TLinearFitter.cxx:1255
 TLinearFitter.cxx:1256
 TLinearFitter.cxx:1257
 TLinearFitter.cxx:1258
 TLinearFitter.cxx:1259
 TLinearFitter.cxx:1260
 TLinearFitter.cxx:1261
 TLinearFitter.cxx:1262
 TLinearFitter.cxx:1263
 TLinearFitter.cxx:1264
 TLinearFitter.cxx:1265
 TLinearFitter.cxx:1266
 TLinearFitter.cxx:1267
 TLinearFitter.cxx:1268
 TLinearFitter.cxx:1269
 TLinearFitter.cxx:1270
 TLinearFitter.cxx:1271
 TLinearFitter.cxx:1272
 TLinearFitter.cxx:1273
 TLinearFitter.cxx:1274
 TLinearFitter.cxx:1275
 TLinearFitter.cxx:1276
 TLinearFitter.cxx:1277
 TLinearFitter.cxx:1278
 TLinearFitter.cxx:1279
 TLinearFitter.cxx:1280
 TLinearFitter.cxx:1281
 TLinearFitter.cxx:1282
 TLinearFitter.cxx:1283
 TLinearFitter.cxx:1284
 TLinearFitter.cxx:1285
 TLinearFitter.cxx:1286
 TLinearFitter.cxx:1287
 TLinearFitter.cxx:1288
 TLinearFitter.cxx:1289
 TLinearFitter.cxx:1290
 TLinearFitter.cxx:1291
 TLinearFitter.cxx:1292
 TLinearFitter.cxx:1293
 TLinearFitter.cxx:1294
 TLinearFitter.cxx:1295
 TLinearFitter.cxx:1296
 TLinearFitter.cxx:1297
 TLinearFitter.cxx:1298
 TLinearFitter.cxx:1299
 TLinearFitter.cxx:1300
 TLinearFitter.cxx:1301
 TLinearFitter.cxx:1302
 TLinearFitter.cxx:1303
 TLinearFitter.cxx:1304
 TLinearFitter.cxx:1305
 TLinearFitter.cxx:1306
 TLinearFitter.cxx:1307
 TLinearFitter.cxx:1308
 TLinearFitter.cxx:1309
 TLinearFitter.cxx:1310
 TLinearFitter.cxx:1311
 TLinearFitter.cxx:1312
 TLinearFitter.cxx:1313
 TLinearFitter.cxx:1314
 TLinearFitter.cxx:1315
 TLinearFitter.cxx:1316
 TLinearFitter.cxx:1317
 TLinearFitter.cxx:1318
 TLinearFitter.cxx:1319
 TLinearFitter.cxx:1320
 TLinearFitter.cxx:1321
 TLinearFitter.cxx:1322
 TLinearFitter.cxx:1323
 TLinearFitter.cxx:1324
 TLinearFitter.cxx:1325
 TLinearFitter.cxx:1326
 TLinearFitter.cxx:1327
 TLinearFitter.cxx:1328
 TLinearFitter.cxx:1329
 TLinearFitter.cxx:1330
 TLinearFitter.cxx:1331
 TLinearFitter.cxx:1332
 TLinearFitter.cxx:1333
 TLinearFitter.cxx:1334
 TLinearFitter.cxx:1335
 TLinearFitter.cxx:1336
 TLinearFitter.cxx:1337
 TLinearFitter.cxx:1338
 TLinearFitter.cxx:1339
 TLinearFitter.cxx:1340
 TLinearFitter.cxx:1341
 TLinearFitter.cxx:1342
 TLinearFitter.cxx:1343
 TLinearFitter.cxx:1344
 TLinearFitter.cxx:1345
 TLinearFitter.cxx:1346
 TLinearFitter.cxx:1347
 TLinearFitter.cxx:1348
 TLinearFitter.cxx:1349
 TLinearFitter.cxx:1350
 TLinearFitter.cxx:1351
 TLinearFitter.cxx:1352
 TLinearFitter.cxx:1353
 TLinearFitter.cxx:1354
 TLinearFitter.cxx:1355
 TLinearFitter.cxx:1356
 TLinearFitter.cxx:1357
 TLinearFitter.cxx:1358
 TLinearFitter.cxx:1359
 TLinearFitter.cxx:1360
 TLinearFitter.cxx:1361
 TLinearFitter.cxx:1362
 TLinearFitter.cxx:1363
 TLinearFitter.cxx:1364
 TLinearFitter.cxx:1365
 TLinearFitter.cxx:1366
 TLinearFitter.cxx:1367
 TLinearFitter.cxx:1368
 TLinearFitter.cxx:1369
 TLinearFitter.cxx:1370
 TLinearFitter.cxx:1371
 TLinearFitter.cxx:1372
 TLinearFitter.cxx:1373
 TLinearFitter.cxx:1374
 TLinearFitter.cxx:1375
 TLinearFitter.cxx:1376
 TLinearFitter.cxx:1377
 TLinearFitter.cxx:1378
 TLinearFitter.cxx:1379
 TLinearFitter.cxx:1380
 TLinearFitter.cxx:1381
 TLinearFitter.cxx:1382
 TLinearFitter.cxx:1383
 TLinearFitter.cxx:1384
 TLinearFitter.cxx:1385
 TLinearFitter.cxx:1386
 TLinearFitter.cxx:1387
 TLinearFitter.cxx:1388
 TLinearFitter.cxx:1389
 TLinearFitter.cxx:1390
 TLinearFitter.cxx:1391
 TLinearFitter.cxx:1392
 TLinearFitter.cxx:1393
 TLinearFitter.cxx:1394
 TLinearFitter.cxx:1395
 TLinearFitter.cxx:1396
 TLinearFitter.cxx:1397
 TLinearFitter.cxx:1398
 TLinearFitter.cxx:1399
 TLinearFitter.cxx:1400
 TLinearFitter.cxx:1401
 TLinearFitter.cxx:1402
 TLinearFitter.cxx:1403
 TLinearFitter.cxx:1404
 TLinearFitter.cxx:1405
 TLinearFitter.cxx:1406
 TLinearFitter.cxx:1407
 TLinearFitter.cxx:1408
 TLinearFitter.cxx:1409
 TLinearFitter.cxx:1410
 TLinearFitter.cxx:1411
 TLinearFitter.cxx:1412
 TLinearFitter.cxx:1413
 TLinearFitter.cxx:1414
 TLinearFitter.cxx:1415
 TLinearFitter.cxx:1416
 TLinearFitter.cxx:1417
 TLinearFitter.cxx:1418
 TLinearFitter.cxx:1419
 TLinearFitter.cxx:1420
 TLinearFitter.cxx:1421
 TLinearFitter.cxx:1422
 TLinearFitter.cxx:1423
 TLinearFitter.cxx:1424
 TLinearFitter.cxx:1425
 TLinearFitter.cxx:1426
 TLinearFitter.cxx:1427
 TLinearFitter.cxx:1428
 TLinearFitter.cxx:1429
 TLinearFitter.cxx:1430
 TLinearFitter.cxx:1431
 TLinearFitter.cxx:1432
 TLinearFitter.cxx:1433
 TLinearFitter.cxx:1434
 TLinearFitter.cxx:1435
 TLinearFitter.cxx:1436
 TLinearFitter.cxx:1437
 TLinearFitter.cxx:1438
 TLinearFitter.cxx:1439
 TLinearFitter.cxx:1440
 TLinearFitter.cxx:1441
 TLinearFitter.cxx:1442
 TLinearFitter.cxx:1443
 TLinearFitter.cxx:1444
 TLinearFitter.cxx:1445
 TLinearFitter.cxx:1446
 TLinearFitter.cxx:1447
 TLinearFitter.cxx:1448
 TLinearFitter.cxx:1449
 TLinearFitter.cxx:1450
 TLinearFitter.cxx:1451
 TLinearFitter.cxx:1452
 TLinearFitter.cxx:1453
 TLinearFitter.cxx:1454
 TLinearFitter.cxx:1455
 TLinearFitter.cxx:1456
 TLinearFitter.cxx:1457
 TLinearFitter.cxx:1458
 TLinearFitter.cxx:1459
 TLinearFitter.cxx:1460
 TLinearFitter.cxx:1461
 TLinearFitter.cxx:1462
 TLinearFitter.cxx:1463
 TLinearFitter.cxx:1464
 TLinearFitter.cxx:1465
 TLinearFitter.cxx:1466
 TLinearFitter.cxx:1467
 TLinearFitter.cxx:1468
 TLinearFitter.cxx:1469
 TLinearFitter.cxx:1470
 TLinearFitter.cxx:1471
 TLinearFitter.cxx:1472
 TLinearFitter.cxx:1473
 TLinearFitter.cxx:1474
 TLinearFitter.cxx:1475
 TLinearFitter.cxx:1476
 TLinearFitter.cxx:1477
 TLinearFitter.cxx:1478
 TLinearFitter.cxx:1479
 TLinearFitter.cxx:1480
 TLinearFitter.cxx:1481
 TLinearFitter.cxx:1482
 TLinearFitter.cxx:1483
 TLinearFitter.cxx:1484
 TLinearFitter.cxx:1485
 TLinearFitter.cxx:1486
 TLinearFitter.cxx:1487
 TLinearFitter.cxx:1488
 TLinearFitter.cxx:1489
 TLinearFitter.cxx:1490
 TLinearFitter.cxx:1491
 TLinearFitter.cxx:1492
 TLinearFitter.cxx:1493
 TLinearFitter.cxx:1494
 TLinearFitter.cxx:1495
 TLinearFitter.cxx:1496
 TLinearFitter.cxx:1497
 TLinearFitter.cxx:1498
 TLinearFitter.cxx:1499
 TLinearFitter.cxx:1500
 TLinearFitter.cxx:1501
 TLinearFitter.cxx:1502
 TLinearFitter.cxx:1503
 TLinearFitter.cxx:1504
 TLinearFitter.cxx:1505
 TLinearFitter.cxx:1506
 TLinearFitter.cxx:1507
 TLinearFitter.cxx:1508
 TLinearFitter.cxx:1509
 TLinearFitter.cxx:1510
 TLinearFitter.cxx:1511
 TLinearFitter.cxx:1512
 TLinearFitter.cxx:1513
 TLinearFitter.cxx:1514
 TLinearFitter.cxx:1515
 TLinearFitter.cxx:1516
 TLinearFitter.cxx:1517
 TLinearFitter.cxx:1518
 TLinearFitter.cxx:1519
 TLinearFitter.cxx:1520
 TLinearFitter.cxx:1521
 TLinearFitter.cxx:1522
 TLinearFitter.cxx:1523
 TLinearFitter.cxx:1524
 TLinearFitter.cxx:1525
 TLinearFitter.cxx:1526
 TLinearFitter.cxx:1527
 TLinearFitter.cxx:1528
 TLinearFitter.cxx:1529
 TLinearFitter.cxx:1530
 TLinearFitter.cxx:1531
 TLinearFitter.cxx:1532
 TLinearFitter.cxx:1533
 TLinearFitter.cxx:1534
 TLinearFitter.cxx:1535
 TLinearFitter.cxx:1536
 TLinearFitter.cxx:1537
 TLinearFitter.cxx:1538
 TLinearFitter.cxx:1539
 TLinearFitter.cxx:1540
 TLinearFitter.cxx:1541
 TLinearFitter.cxx:1542
 TLinearFitter.cxx:1543
 TLinearFitter.cxx:1544
 TLinearFitter.cxx:1545
 TLinearFitter.cxx:1546
 TLinearFitter.cxx:1547
 TLinearFitter.cxx:1548
 TLinearFitter.cxx:1549
 TLinearFitter.cxx:1550
 TLinearFitter.cxx:1551
 TLinearFitter.cxx:1552
 TLinearFitter.cxx:1553
 TLinearFitter.cxx:1554
 TLinearFitter.cxx:1555
 TLinearFitter.cxx:1556
 TLinearFitter.cxx:1557
 TLinearFitter.cxx:1558
 TLinearFitter.cxx:1559
 TLinearFitter.cxx:1560
 TLinearFitter.cxx:1561
 TLinearFitter.cxx:1562
 TLinearFitter.cxx:1563
 TLinearFitter.cxx:1564
 TLinearFitter.cxx:1565
 TLinearFitter.cxx:1566
 TLinearFitter.cxx:1567
 TLinearFitter.cxx:1568
 TLinearFitter.cxx:1569
 TLinearFitter.cxx:1570
 TLinearFitter.cxx:1571
 TLinearFitter.cxx:1572
 TLinearFitter.cxx:1573
 TLinearFitter.cxx:1574
 TLinearFitter.cxx:1575
 TLinearFitter.cxx:1576
 TLinearFitter.cxx:1577
 TLinearFitter.cxx:1578
 TLinearFitter.cxx:1579
 TLinearFitter.cxx:1580
 TLinearFitter.cxx:1581
 TLinearFitter.cxx:1582
 TLinearFitter.cxx:1583
 TLinearFitter.cxx:1584
 TLinearFitter.cxx:1585
 TLinearFitter.cxx:1586
 TLinearFitter.cxx:1587
 TLinearFitter.cxx:1588
 TLinearFitter.cxx:1589
 TLinearFitter.cxx:1590
 TLinearFitter.cxx:1591
 TLinearFitter.cxx:1592
 TLinearFitter.cxx:1593
 TLinearFitter.cxx:1594
 TLinearFitter.cxx:1595
 TLinearFitter.cxx:1596
 TLinearFitter.cxx:1597
 TLinearFitter.cxx:1598
 TLinearFitter.cxx:1599
 TLinearFitter.cxx:1600
 TLinearFitter.cxx:1601
 TLinearFitter.cxx:1602
 TLinearFitter.cxx:1603
 TLinearFitter.cxx:1604
 TLinearFitter.cxx:1605
 TLinearFitter.cxx:1606
 TLinearFitter.cxx:1607
 TLinearFitter.cxx:1608
 TLinearFitter.cxx:1609
 TLinearFitter.cxx:1610
 TLinearFitter.cxx:1611
 TLinearFitter.cxx:1612
 TLinearFitter.cxx:1613
 TLinearFitter.cxx:1614
 TLinearFitter.cxx:1615
 TLinearFitter.cxx:1616
 TLinearFitter.cxx:1617
 TLinearFitter.cxx:1618
 TLinearFitter.cxx:1619
 TLinearFitter.cxx:1620
 TLinearFitter.cxx:1621
 TLinearFitter.cxx:1622
 TLinearFitter.cxx:1623
 TLinearFitter.cxx:1624
 TLinearFitter.cxx:1625
 TLinearFitter.cxx:1626
 TLinearFitter.cxx:1627
 TLinearFitter.cxx:1628
 TLinearFitter.cxx:1629
 TLinearFitter.cxx:1630
 TLinearFitter.cxx:1631
 TLinearFitter.cxx:1632
 TLinearFitter.cxx:1633
 TLinearFitter.cxx:1634
 TLinearFitter.cxx:1635
 TLinearFitter.cxx:1636
 TLinearFitter.cxx:1637
 TLinearFitter.cxx:1638
 TLinearFitter.cxx:1639
 TLinearFitter.cxx:1640
 TLinearFitter.cxx:1641
 TLinearFitter.cxx:1642
 TLinearFitter.cxx:1643
 TLinearFitter.cxx:1644
 TLinearFitter.cxx:1645
 TLinearFitter.cxx:1646
 TLinearFitter.cxx:1647
 TLinearFitter.cxx:1648
 TLinearFitter.cxx:1649
 TLinearFitter.cxx:1650
 TLinearFitter.cxx:1651
 TLinearFitter.cxx:1652
 TLinearFitter.cxx:1653
 TLinearFitter.cxx:1654
 TLinearFitter.cxx:1655
 TLinearFitter.cxx:1656
 TLinearFitter.cxx:1657
 TLinearFitter.cxx:1658
 TLinearFitter.cxx:1659
 TLinearFitter.cxx:1660
 TLinearFitter.cxx:1661
 TLinearFitter.cxx:1662
 TLinearFitter.cxx:1663
 TLinearFitter.cxx:1664
 TLinearFitter.cxx:1665
 TLinearFitter.cxx:1666
 TLinearFitter.cxx:1667
 TLinearFitter.cxx:1668
 TLinearFitter.cxx:1669
 TLinearFitter.cxx:1670
 TLinearFitter.cxx:1671
 TLinearFitter.cxx:1672
 TLinearFitter.cxx:1673
 TLinearFitter.cxx:1674
 TLinearFitter.cxx:1675
 TLinearFitter.cxx:1676
 TLinearFitter.cxx:1677
 TLinearFitter.cxx:1678
 TLinearFitter.cxx:1679
 TLinearFitter.cxx:1680
 TLinearFitter.cxx:1681
 TLinearFitter.cxx:1682
 TLinearFitter.cxx:1683
 TLinearFitter.cxx:1684
 TLinearFitter.cxx:1685
 TLinearFitter.cxx:1686
 TLinearFitter.cxx:1687
 TLinearFitter.cxx:1688
 TLinearFitter.cxx:1689
 TLinearFitter.cxx:1690
 TLinearFitter.cxx:1691
 TLinearFitter.cxx:1692
 TLinearFitter.cxx:1693
 TLinearFitter.cxx:1694
 TLinearFitter.cxx:1695
 TLinearFitter.cxx:1696
 TLinearFitter.cxx:1697
 TLinearFitter.cxx:1698
 TLinearFitter.cxx:1699
 TLinearFitter.cxx:1700
 TLinearFitter.cxx:1701
 TLinearFitter.cxx:1702
 TLinearFitter.cxx:1703
 TLinearFitter.cxx:1704
 TLinearFitter.cxx:1705
 TLinearFitter.cxx:1706
 TLinearFitter.cxx:1707
 TLinearFitter.cxx:1708
 TLinearFitter.cxx:1709
 TLinearFitter.cxx:1710
 TLinearFitter.cxx:1711
 TLinearFitter.cxx:1712
 TLinearFitter.cxx:1713
 TLinearFitter.cxx:1714
 TLinearFitter.cxx:1715
 TLinearFitter.cxx:1716
 TLinearFitter.cxx:1717
 TLinearFitter.cxx:1718
 TLinearFitter.cxx:1719
 TLinearFitter.cxx:1720
 TLinearFitter.cxx:1721
 TLinearFitter.cxx:1722
 TLinearFitter.cxx:1723
 TLinearFitter.cxx:1724
 TLinearFitter.cxx:1725
 TLinearFitter.cxx:1726
 TLinearFitter.cxx:1727
 TLinearFitter.cxx:1728
 TLinearFitter.cxx:1729
 TLinearFitter.cxx:1730
 TLinearFitter.cxx:1731
 TLinearFitter.cxx:1732
 TLinearFitter.cxx:1733
 TLinearFitter.cxx:1734
 TLinearFitter.cxx:1735
 TLinearFitter.cxx:1736
 TLinearFitter.cxx:1737
 TLinearFitter.cxx:1738
 TLinearFitter.cxx:1739
 TLinearFitter.cxx:1740
 TLinearFitter.cxx:1741
 TLinearFitter.cxx:1742
 TLinearFitter.cxx:1743
 TLinearFitter.cxx:1744
 TLinearFitter.cxx:1745
 TLinearFitter.cxx:1746
 TLinearFitter.cxx:1747
 TLinearFitter.cxx:1748
 TLinearFitter.cxx:1749
 TLinearFitter.cxx:1750
 TLinearFitter.cxx:1751
 TLinearFitter.cxx:1752
 TLinearFitter.cxx:1753
 TLinearFitter.cxx:1754
 TLinearFitter.cxx:1755
 TLinearFitter.cxx:1756
 TLinearFitter.cxx:1757
 TLinearFitter.cxx:1758
 TLinearFitter.cxx:1759
 TLinearFitter.cxx:1760
 TLinearFitter.cxx:1761
 TLinearFitter.cxx:1762
 TLinearFitter.cxx:1763
 TLinearFitter.cxx:1764
 TLinearFitter.cxx:1765
 TLinearFitter.cxx:1766
 TLinearFitter.cxx:1767
 TLinearFitter.cxx:1768
 TLinearFitter.cxx:1769
 TLinearFitter.cxx:1770
 TLinearFitter.cxx:1771
 TLinearFitter.cxx:1772
 TLinearFitter.cxx:1773
 TLinearFitter.cxx:1774
 TLinearFitter.cxx:1775
 TLinearFitter.cxx:1776
 TLinearFitter.cxx:1777
 TLinearFitter.cxx:1778
 TLinearFitter.cxx:1779
 TLinearFitter.cxx:1780
 TLinearFitter.cxx:1781
 TLinearFitter.cxx:1782
 TLinearFitter.cxx:1783
 TLinearFitter.cxx:1784
 TLinearFitter.cxx:1785
 TLinearFitter.cxx:1786
 TLinearFitter.cxx:1787
 TLinearFitter.cxx:1788
 TLinearFitter.cxx:1789
 TLinearFitter.cxx:1790
 TLinearFitter.cxx:1791
 TLinearFitter.cxx:1792
 TLinearFitter.cxx:1793
 TLinearFitter.cxx:1794
 TLinearFitter.cxx:1795
 TLinearFitter.cxx:1796
 TLinearFitter.cxx:1797
 TLinearFitter.cxx:1798
 TLinearFitter.cxx:1799
 TLinearFitter.cxx:1800
 TLinearFitter.cxx:1801
 TLinearFitter.cxx:1802
 TLinearFitter.cxx:1803
 TLinearFitter.cxx:1804
 TLinearFitter.cxx:1805
 TLinearFitter.cxx:1806
 TLinearFitter.cxx:1807
 TLinearFitter.cxx:1808
 TLinearFitter.cxx:1809
 TLinearFitter.cxx:1810
 TLinearFitter.cxx:1811
 TLinearFitter.cxx:1812
 TLinearFitter.cxx:1813
 TLinearFitter.cxx:1814
 TLinearFitter.cxx:1815
 TLinearFitter.cxx:1816
 TLinearFitter.cxx:1817
 TLinearFitter.cxx:1818
 TLinearFitter.cxx:1819
 TLinearFitter.cxx:1820
 TLinearFitter.cxx:1821
 TLinearFitter.cxx:1822
 TLinearFitter.cxx:1823
 TLinearFitter.cxx:1824
 TLinearFitter.cxx:1825
 TLinearFitter.cxx:1826
 TLinearFitter.cxx:1827
 TLinearFitter.cxx:1828
 TLinearFitter.cxx:1829
 TLinearFitter.cxx:1830
 TLinearFitter.cxx:1831
 TLinearFitter.cxx:1832
 TLinearFitter.cxx:1833
 TLinearFitter.cxx:1834
 TLinearFitter.cxx:1835
 TLinearFitter.cxx:1836
 TLinearFitter.cxx:1837
 TLinearFitter.cxx:1838
 TLinearFitter.cxx:1839
 TLinearFitter.cxx:1840
 TLinearFitter.cxx:1841
 TLinearFitter.cxx:1842
 TLinearFitter.cxx:1843
 TLinearFitter.cxx:1844
 TLinearFitter.cxx:1845
 TLinearFitter.cxx:1846
 TLinearFitter.cxx:1847
 TLinearFitter.cxx:1848
 TLinearFitter.cxx:1849
 TLinearFitter.cxx:1850
 TLinearFitter.cxx:1851
 TLinearFitter.cxx:1852
 TLinearFitter.cxx:1853
 TLinearFitter.cxx:1854
 TLinearFitter.cxx:1855
 TLinearFitter.cxx:1856
 TLinearFitter.cxx:1857
 TLinearFitter.cxx:1858
 TLinearFitter.cxx:1859
 TLinearFitter.cxx:1860
 TLinearFitter.cxx:1861
 TLinearFitter.cxx:1862
 TLinearFitter.cxx:1863
 TLinearFitter.cxx:1864
 TLinearFitter.cxx:1865
 TLinearFitter.cxx:1866
 TLinearFitter.cxx:1867
 TLinearFitter.cxx:1868
 TLinearFitter.cxx:1869
 TLinearFitter.cxx:1870
 TLinearFitter.cxx:1871
 TLinearFitter.cxx:1872
 TLinearFitter.cxx:1873
 TLinearFitter.cxx:1874
 TLinearFitter.cxx:1875
 TLinearFitter.cxx:1876
 TLinearFitter.cxx:1877
 TLinearFitter.cxx:1878
 TLinearFitter.cxx:1879
 TLinearFitter.cxx:1880
 TLinearFitter.cxx:1881
 TLinearFitter.cxx:1882
 TLinearFitter.cxx:1883
 TLinearFitter.cxx:1884
 TLinearFitter.cxx:1885
 TLinearFitter.cxx:1886
 TLinearFitter.cxx:1887
 TLinearFitter.cxx:1888
 TLinearFitter.cxx:1889
 TLinearFitter.cxx:1890
 TLinearFitter.cxx:1891
 TLinearFitter.cxx:1892
 TLinearFitter.cxx:1893
 TLinearFitter.cxx:1894
 TLinearFitter.cxx:1895
 TLinearFitter.cxx:1896
 TLinearFitter.cxx:1897
 TLinearFitter.cxx:1898
 TLinearFitter.cxx:1899
 TLinearFitter.cxx:1900
 TLinearFitter.cxx:1901
 TLinearFitter.cxx:1902
 TLinearFitter.cxx:1903
 TLinearFitter.cxx:1904
 TLinearFitter.cxx:1905
 TLinearFitter.cxx:1906
 TLinearFitter.cxx:1907
 TLinearFitter.cxx:1908
 TLinearFitter.cxx:1909
 TLinearFitter.cxx:1910
 TLinearFitter.cxx:1911
 TLinearFitter.cxx:1912
 TLinearFitter.cxx:1913
 TLinearFitter.cxx:1914
 TLinearFitter.cxx:1915
 TLinearFitter.cxx:1916
 TLinearFitter.cxx:1917
 TLinearFitter.cxx:1918
 TLinearFitter.cxx:1919
 TLinearFitter.cxx:1920
 TLinearFitter.cxx:1921
 TLinearFitter.cxx:1922
 TLinearFitter.cxx:1923
 TLinearFitter.cxx:1924
 TLinearFitter.cxx:1925
 TLinearFitter.cxx:1926
 TLinearFitter.cxx:1927
 TLinearFitter.cxx:1928
 TLinearFitter.cxx:1929
 TLinearFitter.cxx:1930
 TLinearFitter.cxx:1931
 TLinearFitter.cxx:1932
 TLinearFitter.cxx:1933
 TLinearFitter.cxx:1934
 TLinearFitter.cxx:1935
 TLinearFitter.cxx:1936
 TLinearFitter.cxx:1937
 TLinearFitter.cxx:1938
 TLinearFitter.cxx:1939
 TLinearFitter.cxx:1940
 TLinearFitter.cxx:1941
 TLinearFitter.cxx:1942
 TLinearFitter.cxx:1943
 TLinearFitter.cxx:1944
 TLinearFitter.cxx:1945
 TLinearFitter.cxx:1946
 TLinearFitter.cxx:1947
 TLinearFitter.cxx:1948
 TLinearFitter.cxx:1949
 TLinearFitter.cxx:1950
 TLinearFitter.cxx:1951
 TLinearFitter.cxx:1952
 TLinearFitter.cxx:1953
 TLinearFitter.cxx:1954
 TLinearFitter.cxx:1955
 TLinearFitter.cxx:1956
 TLinearFitter.cxx:1957
 TLinearFitter.cxx:1958
 TLinearFitter.cxx:1959
 TLinearFitter.cxx:1960
 TLinearFitter.cxx:1961
 TLinearFitter.cxx:1962
 TLinearFitter.cxx:1963
 TLinearFitter.cxx:1964
 TLinearFitter.cxx:1965
 TLinearFitter.cxx:1966
 TLinearFitter.cxx:1967
 TLinearFitter.cxx:1968
 TLinearFitter.cxx:1969
 TLinearFitter.cxx:1970
 TLinearFitter.cxx:1971
 TLinearFitter.cxx:1972
 TLinearFitter.cxx:1973
 TLinearFitter.cxx:1974
 TLinearFitter.cxx:1975
 TLinearFitter.cxx:1976
 TLinearFitter.cxx:1977
 TLinearFitter.cxx:1978
 TLinearFitter.cxx:1979
 TLinearFitter.cxx:1980
 TLinearFitter.cxx:1981
 TLinearFitter.cxx:1982
 TLinearFitter.cxx:1983
 TLinearFitter.cxx:1984
 TLinearFitter.cxx:1985
 TLinearFitter.cxx:1986
 TLinearFitter.cxx:1987
 TLinearFitter.cxx:1988
 TLinearFitter.cxx:1989
 TLinearFitter.cxx:1990
 TLinearFitter.cxx:1991
 TLinearFitter.cxx:1992
 TLinearFitter.cxx:1993
 TLinearFitter.cxx:1994
 TLinearFitter.cxx:1995
 TLinearFitter.cxx:1996
 TLinearFitter.cxx:1997
 TLinearFitter.cxx:1998
 TLinearFitter.cxx:1999
 TLinearFitter.cxx:2000
 TLinearFitter.cxx:2001
 TLinearFitter.cxx:2002
 TLinearFitter.cxx:2003
 TLinearFitter.cxx:2004
 TLinearFitter.cxx:2005
 TLinearFitter.cxx:2006
 TLinearFitter.cxx:2007
 TLinearFitter.cxx:2008
 TLinearFitter.cxx:2009
 TLinearFitter.cxx:2010
 TLinearFitter.cxx:2011
 TLinearFitter.cxx:2012
 TLinearFitter.cxx:2013
 TLinearFitter.cxx:2014
 TLinearFitter.cxx:2015
 TLinearFitter.cxx:2016
 TLinearFitter.cxx:2017
 TLinearFitter.cxx:2018
 TLinearFitter.cxx:2019
 TLinearFitter.cxx:2020
 TLinearFitter.cxx:2021
 TLinearFitter.cxx:2022
 TLinearFitter.cxx:2023
 TLinearFitter.cxx:2024
 TLinearFitter.cxx:2025
 TLinearFitter.cxx:2026
 TLinearFitter.cxx:2027
 TLinearFitter.cxx:2028
 TLinearFitter.cxx:2029
 TLinearFitter.cxx:2030
 TLinearFitter.cxx:2031
 TLinearFitter.cxx:2032
 TLinearFitter.cxx:2033
 TLinearFitter.cxx:2034
 TLinearFitter.cxx:2035
 TLinearFitter.cxx:2036
 TLinearFitter.cxx:2037
 TLinearFitter.cxx:2038
 TLinearFitter.cxx:2039
 TLinearFitter.cxx:2040
 TLinearFitter.cxx:2041
 TLinearFitter.cxx:2042
 TLinearFitter.cxx:2043
 TLinearFitter.cxx:2044
 TLinearFitter.cxx:2045
 TLinearFitter.cxx:2046
 TLinearFitter.cxx:2047
 TLinearFitter.cxx:2048
 TLinearFitter.cxx:2049
 TLinearFitter.cxx:2050
 TLinearFitter.cxx:2051
 TLinearFitter.cxx:2052
 TLinearFitter.cxx:2053
 TLinearFitter.cxx:2054
 TLinearFitter.cxx:2055
 TLinearFitter.cxx:2056
 TLinearFitter.cxx:2057
 TLinearFitter.cxx:2058
 TLinearFitter.cxx:2059
 TLinearFitter.cxx:2060
 TLinearFitter.cxx:2061
 TLinearFitter.cxx:2062
 TLinearFitter.cxx:2063
 TLinearFitter.cxx:2064
 TLinearFitter.cxx:2065
 TLinearFitter.cxx:2066
 TLinearFitter.cxx:2067
 TLinearFitter.cxx:2068
 TLinearFitter.cxx:2069
 TLinearFitter.cxx:2070
 TLinearFitter.cxx:2071
 TLinearFitter.cxx:2072
 TLinearFitter.cxx:2073
 TLinearFitter.cxx:2074
 TLinearFitter.cxx:2075
 TLinearFitter.cxx:2076
 TLinearFitter.cxx:2077
 TLinearFitter.cxx:2078
 TLinearFitter.cxx:2079
 TLinearFitter.cxx:2080
 TLinearFitter.cxx:2081
 TLinearFitter.cxx:2082
 TLinearFitter.cxx:2083
 TLinearFitter.cxx:2084
 TLinearFitter.cxx:2085
 TLinearFitter.cxx:2086
 TLinearFitter.cxx:2087
 TLinearFitter.cxx:2088
 TLinearFitter.cxx:2089
 TLinearFitter.cxx:2090
 TLinearFitter.cxx:2091
 TLinearFitter.cxx:2092
 TLinearFitter.cxx:2093
 TLinearFitter.cxx:2094
 TLinearFitter.cxx:2095
 TLinearFitter.cxx:2096
 TLinearFitter.cxx:2097
 TLinearFitter.cxx:2098
 TLinearFitter.cxx:2099
 TLinearFitter.cxx:2100
 TLinearFitter.cxx:2101
 TLinearFitter.cxx:2102
 TLinearFitter.cxx:2103
 TLinearFitter.cxx:2104
 TLinearFitter.cxx:2105
 TLinearFitter.cxx:2106
 TLinearFitter.cxx:2107
 TLinearFitter.cxx:2108
 TLinearFitter.cxx:2109
 TLinearFitter.cxx:2110
 TLinearFitter.cxx:2111
 TLinearFitter.cxx:2112
 TLinearFitter.cxx:2113
 TLinearFitter.cxx:2114
 TLinearFitter.cxx:2115
 TLinearFitter.cxx:2116
 TLinearFitter.cxx:2117
 TLinearFitter.cxx:2118
 TLinearFitter.cxx:2119
 TLinearFitter.cxx:2120
 TLinearFitter.cxx:2121
 TLinearFitter.cxx:2122
 TLinearFitter.cxx:2123
 TLinearFitter.cxx:2124
 TLinearFitter.cxx:2125
 TLinearFitter.cxx:2126
 TLinearFitter.cxx:2127
 TLinearFitter.cxx:2128
 TLinearFitter.cxx:2129
 TLinearFitter.cxx:2130
 TLinearFitter.cxx:2131
 TLinearFitter.cxx:2132
 TLinearFitter.cxx:2133
 TLinearFitter.cxx:2134
 TLinearFitter.cxx:2135
 TLinearFitter.cxx:2136
 TLinearFitter.cxx:2137
 TLinearFitter.cxx:2138
 TLinearFitter.cxx:2139
 TLinearFitter.cxx:2140
 TLinearFitter.cxx:2141
 TLinearFitter.cxx:2142
 TLinearFitter.cxx:2143
 TLinearFitter.cxx:2144
 TLinearFitter.cxx:2145
 TLinearFitter.cxx:2146
 TLinearFitter.cxx:2147
 TLinearFitter.cxx:2148
 TLinearFitter.cxx:2149
 TLinearFitter.cxx:2150
 TLinearFitter.cxx:2151
 TLinearFitter.cxx:2152
 TLinearFitter.cxx:2153
 TLinearFitter.cxx:2154
 TLinearFitter.cxx:2155
 TLinearFitter.cxx:2156
 TLinearFitter.cxx:2157
 TLinearFitter.cxx:2158
 TLinearFitter.cxx:2159
 TLinearFitter.cxx:2160
 TLinearFitter.cxx:2161
 TLinearFitter.cxx:2162
 TLinearFitter.cxx:2163
 TLinearFitter.cxx:2164
 TLinearFitter.cxx:2165
 TLinearFitter.cxx:2166
 TLinearFitter.cxx:2167
 TLinearFitter.cxx:2168
 TLinearFitter.cxx:2169
 TLinearFitter.cxx:2170
 TLinearFitter.cxx:2171
 TLinearFitter.cxx:2172
 TLinearFitter.cxx:2173
 TLinearFitter.cxx:2174
 TLinearFitter.cxx:2175
 TLinearFitter.cxx:2176
 TLinearFitter.cxx:2177
 TLinearFitter.cxx:2178
 TLinearFitter.cxx:2179
 TLinearFitter.cxx:2180
 TLinearFitter.cxx:2181
 TLinearFitter.cxx:2182
 TLinearFitter.cxx:2183
 TLinearFitter.cxx:2184
 TLinearFitter.cxx:2185
 TLinearFitter.cxx:2186
 TLinearFitter.cxx:2187
 TLinearFitter.cxx:2188
 TLinearFitter.cxx:2189
 TLinearFitter.cxx:2190
 TLinearFitter.cxx:2191
 TLinearFitter.cxx:2192
 TLinearFitter.cxx:2193
 TLinearFitter.cxx:2194
 TLinearFitter.cxx:2195
 TLinearFitter.cxx:2196
 TLinearFitter.cxx:2197
 TLinearFitter.cxx:2198
 TLinearFitter.cxx:2199
 TLinearFitter.cxx:2200
 TLinearFitter.cxx:2201
 TLinearFitter.cxx:2202
 TLinearFitter.cxx:2203
 TLinearFitter.cxx:2204
 TLinearFitter.cxx:2205
 TLinearFitter.cxx:2206
 TLinearFitter.cxx:2207
 TLinearFitter.cxx:2208
 TLinearFitter.cxx:2209
 TLinearFitter.cxx:2210
 TLinearFitter.cxx:2211
 TLinearFitter.cxx:2212
 TLinearFitter.cxx:2213
 TLinearFitter.cxx:2214
 TLinearFitter.cxx:2215
 TLinearFitter.cxx:2216
 TLinearFitter.cxx:2217
 TLinearFitter.cxx:2218
 TLinearFitter.cxx:2219
 TLinearFitter.cxx:2220
 TLinearFitter.cxx:2221
 TLinearFitter.cxx:2222
 TLinearFitter.cxx:2223
 TLinearFitter.cxx:2224
 TLinearFitter.cxx:2225
 TLinearFitter.cxx:2226
 TLinearFitter.cxx:2227
 TLinearFitter.cxx:2228
 TLinearFitter.cxx:2229
 TLinearFitter.cxx:2230
 TLinearFitter.cxx:2231
 TLinearFitter.cxx:2232
 TLinearFitter.cxx:2233
 TLinearFitter.cxx:2234
 TLinearFitter.cxx:2235
 TLinearFitter.cxx:2236
 TLinearFitter.cxx:2237
 TLinearFitter.cxx:2238
 TLinearFitter.cxx:2239
 TLinearFitter.cxx:2240
 TLinearFitter.cxx:2241
 TLinearFitter.cxx:2242
 TLinearFitter.cxx:2243
 TLinearFitter.cxx:2244
 TLinearFitter.cxx:2245
 TLinearFitter.cxx:2246
 TLinearFitter.cxx:2247
 TLinearFitter.cxx:2248
 TLinearFitter.cxx:2249
 TLinearFitter.cxx:2250
 TLinearFitter.cxx:2251
 TLinearFitter.cxx:2252
 TLinearFitter.cxx:2253
 TLinearFitter.cxx:2254
 TLinearFitter.cxx:2255
 TLinearFitter.cxx:2256
 TLinearFitter.cxx:2257
 TLinearFitter.cxx:2258
 TLinearFitter.cxx:2259
 TLinearFitter.cxx:2260
 TLinearFitter.cxx:2261
 TLinearFitter.cxx:2262
 TLinearFitter.cxx:2263
 TLinearFitter.cxx:2264
 TLinearFitter.cxx:2265
 TLinearFitter.cxx:2266
 TLinearFitter.cxx:2267
 TLinearFitter.cxx:2268
 TLinearFitter.cxx:2269
 TLinearFitter.cxx:2270
 TLinearFitter.cxx:2271
 TLinearFitter.cxx:2272
 TLinearFitter.cxx:2273
 TLinearFitter.cxx:2274
 TLinearFitter.cxx:2275
 TLinearFitter.cxx:2276
 TLinearFitter.cxx:2277
 TLinearFitter.cxx:2278
 TLinearFitter.cxx:2279
 TLinearFitter.cxx:2280
 TLinearFitter.cxx:2281
 TLinearFitter.cxx:2282
 TLinearFitter.cxx:2283
 TLinearFitter.cxx:2284
 TLinearFitter.cxx:2285
 TLinearFitter.cxx:2286
 TLinearFitter.cxx:2287
 TLinearFitter.cxx:2288
 TLinearFitter.cxx:2289
 TLinearFitter.cxx:2290
 TLinearFitter.cxx:2291
 TLinearFitter.cxx:2292
 TLinearFitter.cxx:2293
 TLinearFitter.cxx:2294
 TLinearFitter.cxx:2295
 TLinearFitter.cxx:2296
 TLinearFitter.cxx:2297
 TLinearFitter.cxx:2298
 TLinearFitter.cxx:2299
 TLinearFitter.cxx:2300
 TLinearFitter.cxx:2301
 TLinearFitter.cxx:2302
 TLinearFitter.cxx:2303
 TLinearFitter.cxx:2304
 TLinearFitter.cxx:2305
 TLinearFitter.cxx:2306
 TLinearFitter.cxx:2307
 TLinearFitter.cxx:2308
 TLinearFitter.cxx:2309
 TLinearFitter.cxx:2310
 TLinearFitter.cxx:2311
 TLinearFitter.cxx:2312
 TLinearFitter.cxx:2313
 TLinearFitter.cxx:2314
 TLinearFitter.cxx:2315
 TLinearFitter.cxx:2316
 TLinearFitter.cxx:2317
 TLinearFitter.cxx:2318
 TLinearFitter.cxx:2319
 TLinearFitter.cxx:2320
 TLinearFitter.cxx:2321
 TLinearFitter.cxx:2322
 TLinearFitter.cxx:2323
 TLinearFitter.cxx:2324
 TLinearFitter.cxx:2325
 TLinearFitter.cxx:2326
 TLinearFitter.cxx:2327
 TLinearFitter.cxx:2328
 TLinearFitter.cxx:2329
 TLinearFitter.cxx:2330
 TLinearFitter.cxx:2331
 TLinearFitter.cxx:2332
 TLinearFitter.cxx:2333
 TLinearFitter.cxx:2334
 TLinearFitter.cxx:2335
 TLinearFitter.cxx:2336
 TLinearFitter.cxx:2337
 TLinearFitter.cxx:2338
 TLinearFitter.cxx:2339
 TLinearFitter.cxx:2340
 TLinearFitter.cxx:2341
 TLinearFitter.cxx:2342
 TLinearFitter.cxx:2343
 TLinearFitter.cxx:2344
 TLinearFitter.cxx:2345
 TLinearFitter.cxx:2346
 TLinearFitter.cxx:2347
 TLinearFitter.cxx:2348
 TLinearFitter.cxx:2349
 TLinearFitter.cxx:2350
 TLinearFitter.cxx:2351
 TLinearFitter.cxx:2352
 TLinearFitter.cxx:2353
 TLinearFitter.cxx:2354
 TLinearFitter.cxx:2355
 TLinearFitter.cxx:2356
 TLinearFitter.cxx:2357
 TLinearFitter.cxx:2358
 TLinearFitter.cxx:2359
 TLinearFitter.cxx:2360
 TLinearFitter.cxx:2361
 TLinearFitter.cxx:2362
 TLinearFitter.cxx:2363
 TLinearFitter.cxx:2364
 TLinearFitter.cxx:2365
 TLinearFitter.cxx:2366
 TLinearFitter.cxx:2367
 TLinearFitter.cxx:2368
 TLinearFitter.cxx:2369
 TLinearFitter.cxx:2370
 TLinearFitter.cxx:2371
 TLinearFitter.cxx:2372
 TLinearFitter.cxx:2373
 TLinearFitter.cxx:2374
 TLinearFitter.cxx:2375
 TLinearFitter.cxx:2376
 TLinearFitter.cxx:2377
 TLinearFitter.cxx:2378
 TLinearFitter.cxx:2379
 TLinearFitter.cxx:2380
 TLinearFitter.cxx:2381
 TLinearFitter.cxx:2382
 TLinearFitter.cxx:2383
 TLinearFitter.cxx:2384
 TLinearFitter.cxx:2385
 TLinearFitter.cxx:2386
 TLinearFitter.cxx:2387
 TLinearFitter.cxx:2388
 TLinearFitter.cxx:2389
 TLinearFitter.cxx:2390
 TLinearFitter.cxx:2391
 TLinearFitter.cxx:2392
 TLinearFitter.cxx:2393
 TLinearFitter.cxx:2394
 TLinearFitter.cxx:2395
 TLinearFitter.cxx:2396
 TLinearFitter.cxx:2397
 TLinearFitter.cxx:2398
 TLinearFitter.cxx:2399
 TLinearFitter.cxx:2400
 TLinearFitter.cxx:2401
 TLinearFitter.cxx:2402
 TLinearFitter.cxx:2403
 TLinearFitter.cxx:2404
 TLinearFitter.cxx:2405
 TLinearFitter.cxx:2406
 TLinearFitter.cxx:2407
 TLinearFitter.cxx:2408
 TLinearFitter.cxx:2409
 TLinearFitter.cxx:2410
 TLinearFitter.cxx:2411
 TLinearFitter.cxx:2412
 TLinearFitter.cxx:2413
 TLinearFitter.cxx:2414
 TLinearFitter.cxx:2415
 TLinearFitter.cxx:2416
 TLinearFitter.cxx:2417
 TLinearFitter.cxx:2418
 TLinearFitter.cxx:2419
 TLinearFitter.cxx:2420
 TLinearFitter.cxx:2421
 TLinearFitter.cxx:2422
 TLinearFitter.cxx:2423
 TLinearFitter.cxx:2424
 TLinearFitter.cxx:2425
 TLinearFitter.cxx:2426
 TLinearFitter.cxx:2427
 TLinearFitter.cxx:2428
 TLinearFitter.cxx:2429
 TLinearFitter.cxx:2430
 TLinearFitter.cxx:2431
 TLinearFitter.cxx:2432
 TLinearFitter.cxx:2433
 TLinearFitter.cxx:2434
 TLinearFitter.cxx:2435
 TLinearFitter.cxx:2436
 TLinearFitter.cxx:2437
 TLinearFitter.cxx:2438
 TLinearFitter.cxx:2439
 TLinearFitter.cxx:2440
 TLinearFitter.cxx:2441
 TLinearFitter.cxx:2442
 TLinearFitter.cxx:2443
 TLinearFitter.cxx:2444
 TLinearFitter.cxx:2445
 TLinearFitter.cxx:2446
 TLinearFitter.cxx:2447
 TLinearFitter.cxx:2448
 TLinearFitter.cxx:2449
 TLinearFitter.cxx:2450
 TLinearFitter.cxx:2451
 TLinearFitter.cxx:2452
 TLinearFitter.cxx:2453
 TLinearFitter.cxx:2454
 TLinearFitter.cxx:2455
 TLinearFitter.cxx:2456
 TLinearFitter.cxx:2457
 TLinearFitter.cxx:2458
 TLinearFitter.cxx:2459
 TLinearFitter.cxx:2460
 TLinearFitter.cxx:2461
 TLinearFitter.cxx:2462
 TLinearFitter.cxx:2463
 TLinearFitter.cxx:2464
 TLinearFitter.cxx:2465
 TLinearFitter.cxx:2466
 TLinearFitter.cxx:2467
 TLinearFitter.cxx:2468
 TLinearFitter.cxx:2469
 TLinearFitter.cxx:2470
 TLinearFitter.cxx:2471
 TLinearFitter.cxx:2472
 TLinearFitter.cxx:2473
 TLinearFitter.cxx:2474
 TLinearFitter.cxx:2475
 TLinearFitter.cxx:2476
 TLinearFitter.cxx:2477
 TLinearFitter.cxx:2478
 TLinearFitter.cxx:2479
 TLinearFitter.cxx:2480
 TLinearFitter.cxx:2481
 TLinearFitter.cxx:2482
 TLinearFitter.cxx:2483
 TLinearFitter.cxx:2484
 TLinearFitter.cxx:2485
 TLinearFitter.cxx:2486
 TLinearFitter.cxx:2487
 TLinearFitter.cxx:2488
 TLinearFitter.cxx:2489
 TLinearFitter.cxx:2490
 TLinearFitter.cxx:2491
 TLinearFitter.cxx:2492
 TLinearFitter.cxx:2493
 TLinearFitter.cxx:2494
 TLinearFitter.cxx:2495
 TLinearFitter.cxx:2496
 TLinearFitter.cxx:2497
 TLinearFitter.cxx:2498
 TLinearFitter.cxx:2499
 TLinearFitter.cxx:2500
 TLinearFitter.cxx:2501
 TLinearFitter.cxx:2502
 TLinearFitter.cxx:2503
 TLinearFitter.cxx:2504
 TLinearFitter.cxx:2505
 TLinearFitter.cxx:2506
 TLinearFitter.cxx:2507
 TLinearFitter.cxx:2508
 TLinearFitter.cxx:2509
 TLinearFitter.cxx:2510
 TLinearFitter.cxx:2511
 TLinearFitter.cxx:2512
 TLinearFitter.cxx:2513
 TLinearFitter.cxx:2514
 TLinearFitter.cxx:2515
 TLinearFitter.cxx:2516
 TLinearFitter.cxx:2517
 TLinearFitter.cxx:2518
 TLinearFitter.cxx:2519
 TLinearFitter.cxx:2520
 TLinearFitter.cxx:2521
 TLinearFitter.cxx:2522
 TLinearFitter.cxx:2523
 TLinearFitter.cxx:2524
 TLinearFitter.cxx:2525
 TLinearFitter.cxx:2526
 TLinearFitter.cxx:2527
 TLinearFitter.cxx:2528
 TLinearFitter.cxx:2529
 TLinearFitter.cxx:2530
 TLinearFitter.cxx:2531
 TLinearFitter.cxx:2532
 TLinearFitter.cxx:2533
 TLinearFitter.cxx:2534
 TLinearFitter.cxx:2535
 TLinearFitter.cxx:2536
 TLinearFitter.cxx:2537
 TLinearFitter.cxx:2538
 TLinearFitter.cxx:2539
 TLinearFitter.cxx:2540
 TLinearFitter.cxx:2541
 TLinearFitter.cxx:2542
 TLinearFitter.cxx:2543
 TLinearFitter.cxx:2544
 TLinearFitter.cxx:2545
 TLinearFitter.cxx:2546
 TLinearFitter.cxx:2547
 TLinearFitter.cxx:2548
 TLinearFitter.cxx:2549
 TLinearFitter.cxx:2550
 TLinearFitter.cxx:2551
 TLinearFitter.cxx:2552
 TLinearFitter.cxx:2553
 TLinearFitter.cxx:2554
 TLinearFitter.cxx:2555
 TLinearFitter.cxx:2556
 TLinearFitter.cxx:2557
 TLinearFitter.cxx:2558
 TLinearFitter.cxx:2559
 TLinearFitter.cxx:2560
 TLinearFitter.cxx:2561
 TLinearFitter.cxx:2562
 TLinearFitter.cxx:2563
 TLinearFitter.cxx:2564
 TLinearFitter.cxx:2565
 TLinearFitter.cxx:2566
 TLinearFitter.cxx:2567
 TLinearFitter.cxx:2568
 TLinearFitter.cxx:2569
 TLinearFitter.cxx:2570
 TLinearFitter.cxx:2571
 TLinearFitter.cxx:2572
 TLinearFitter.cxx:2573
 TLinearFitter.cxx:2574
 TLinearFitter.cxx:2575
 TLinearFitter.cxx:2576
 TLinearFitter.cxx:2577
 TLinearFitter.cxx:2578
 TLinearFitter.cxx:2579
 TLinearFitter.cxx:2580
 TLinearFitter.cxx:2581