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

/*************************************************************************
*                                                                       *
* 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"
#include "TClass.h"
#include "TROOT.h"

ClassImp(TLinearFitter)

std::map<TString,TFormula*> TLinearFitter::fgFormulaMap;

//////////////////////////////////////////////////////////////////////////
//
// 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.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
//       --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();
fFunctions.Clear();

}

//______________________________________________________________________________
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;

// use clear instead of delete
fFunctions.Clear();
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;
}

//______________________________________________________________________________
{
//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)){
return;
}
}

//______________________________________________________________________________
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){
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++)
}
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()){
// ffunctions can be TF1 or TFormula depending on how they are created
TObject * obj = fFunctions.UncheckedAt(ii);
if (obj->IsA() == TFormula::Class() ) {
TFormula *f1 = (TFormula*)(obj);
fVal[ii]=f1->EvalPar(x)/e;
}
else if  (obj->IsA() == TF1::Class() ) {
TF1 *f1 = (TF1*)(obj);
fVal[ii]=f1->EvalPar(x)/e;
}
else {
Error("AddToDesign","Basis Function %s is of an invalid type %s",obj->GetName(),obj->IsA()->GetName());
return;
}
} 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;
}
}
}
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();
}
}
}
}

//______________________________________________________________________________
{
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;
}
}

//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 *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;
//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++){
}
}
for (Int_t i=0; i<fNfunctions; i++)
c=TMath::Sqrt(c);
ci[ipoint]=c*t*chidf;
}

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 *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];
for (Int_t irow=0; irow<fNfunctions; irow++){
sum_vector[irow]=0;
for (Int_t icol=0; icol<fNfunctions; icol++)
}
for (Int_t i=0; i<fNfunctions; i++)
c=TMath::Sqrt(c);
gr2->SetPoint(ipoint, xy[0], xy[1], fInputFunction->EvalPar(xy));
gr2->GetEZ()[ipoint]=c*t*chidf;
}
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 *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);
c=0;
for (Int_t irow=0; irow<fNfunctions; irow++){
sum_vector[irow]=0;
for (Int_t icol=0; icol<fNfunctions; icol++)
}
for (Int_t i=0; i<fNfunctions; i++)
c=TMath::Sqrt(c);
hfit->SetBinContent(binx, biny, binz, fInputFunction->EvalPar(x));
hfit->SetBinError(binx, biny, binz, c*t*chidf);
}
}
}
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())) {
return -1;
}
}
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 = 0, 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();
// look first if exists in the map
TFormula * f = nullptr;
if (fgFormulaMap.count(replaceformula ) > 0)
f = fgFormulaMap.find(replaceformula )->second;
else {
// create a new formula and add in the static map
f = new TFormula("f", replaceformula.Data());
{
R__LOCKGUARD2(gROOTMutex);
fgFormulaMap[replaceformula]=f;
}
}
if (!f) {
Error("TLinearFitter", "f_linear not allocated");
return;
}
special=f->GetNumber();
}

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++) {
}
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->GetFormula());

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;
}

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->GetFormula());

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;
}

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->GetFormula());

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;
}
}

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 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->GetFormula());

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;
}
}
}
}

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)
{
Int_t old_matr_size = fNfunctions;
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 {
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++){
}
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
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++)

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
TLinearFitter.cxx:2582
TLinearFitter.cxx:2583
TLinearFitter.cxx:2584
TLinearFitter.cxx:2585
TLinearFitter.cxx:2586
TLinearFitter.cxx:2587
TLinearFitter.cxx:2588
TLinearFitter.cxx:2589
TLinearFitter.cxx:2590
TLinearFitter.cxx:2591
TLinearFitter.cxx:2592
TLinearFitter.cxx:2593
TLinearFitter.cxx:2594
TLinearFitter.cxx:2595
TLinearFitter.cxx:2596
TLinearFitter.cxx:2597
TLinearFitter.cxx:2598
TLinearFitter.cxx:2599
TLinearFitter.cxx:2600
TLinearFitter.cxx:2601
TLinearFitter.cxx:2602
TLinearFitter.cxx:2603
TLinearFitter.cxx:2604
TLinearFitter.cxx:2605
TLinearFitter.cxx:2606
TLinearFitter.cxx:2607
TLinearFitter.cxx:2608
TLinearFitter.cxx:2609
TLinearFitter.cxx:2610
TLinearFitter.cxx:2611
TLinearFitter.cxx:2612
TLinearFitter.cxx:2613