ROOT   6.08/07 Reference Guide
TLinearMinimizer.cxx
Go to the documentation of this file.
1 // @(#)root/minuit:$Id$
2 // Author: L. Moneta Wed Oct 25 16:28:55 2006
3
4 /**********************************************************************
5  * *
6  * Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
7  * *
8  * *
9  **********************************************************************/
10
11 // Implementation file for class TLinearMinimizer
12
13 #include "TLinearMinimizer.h"
14 #include "Math/IParamFunction.h"
15 #include "TF1.h"
16 #include "TUUID.h"
17 #include "TROOT.h"
18 #include "Fit/BasicFCN.h"
19 #include "Fit/BinData.h"
20 #include "Fit/Chi2FCN.h"
21
22 #include "TLinearFitter.h"
23 #include "TVirtualMutex.h"
24
25 #include <iostream>
26 #include <cassert>
27 #include <algorithm>
28 #include <functional>
29
30
31
32 // namespace ROOT {
33
34 // namespace Fit {
35
36
37 // structure used for creating the TF1 representing the basis functions
38 // they are the derivatives w.r.t the parameters of the model function
39 template<class Func>
40 struct BasisFunction {
41  BasisFunction(const Func & f, int k) :
42  fKPar(k),
43  fFunc(&f)
44  {}
45
46  double operator() ( double * x, double *) {
47  return fFunc->ParameterDerivative(x,fKPar);
48  }
49
50  unsigned int fKPar; // param component
51  const Func * fFunc;
52 };
53
54
55 //______________________________________________________________________________
56 //
57 // TLinearMinimizer, simple class implementing the ROOT::Math::Minimizer interface using
58 // TLinearFitter.
59 // This class uses TLinearFitter to find directly (by solving a system of linear equations)
60 // the minimum of a
61 // least-square function which has a linear dependence in the fit parameters.
62 // This class is not used directly, but via the ROOT::Fitter class, when calling the
63 // LinearFit method. It is instantiates using the plug-in manager (plug-in name is "Linear")
64 //
65 //__________________________________________________________________________________________
66
67
69
70
72  fRobust(false),
73  fDim(0),
74  fNFree(0),
75  fMinVal(0),
76  fObjFunc(0),
77  fFitter(0)
78 {
79  // Default constructor implementation.
80  // type is not used - needed for consistency with other minimizer plug-ins
81 }
82
84  fRobust(false),
85  fDim(0),
86  fNFree(0),
87  fMinVal(0),
88  fObjFunc(0),
89  fFitter(0)
90 {
91  // constructor passing a type of algorithm, (supported now robust via LTS regression)
92
93  // select type from the string
94  std::string algoname(type);
95  std::transform(algoname.begin(), algoname.end(), algoname.begin(), (int(*)(int)) tolower );
96
97  if (algoname.find("robust") != std::string::npos) fRobust = true;
98
99 }
100
102 {
103  // Destructor implementation.
104  if (fFitter) delete fFitter;
105 }
106
108  Minimizer()
109 {
110  // Implementation of copy constructor.
111 }
112
114 {
115  // Implementation of assignment operator.
116  if (this == &rhs) return *this; // time saving self-test
117  return *this;
118 }
119
120
122  // Set function to be minimized. Flag an error since only support Gradient objective functions
123
124  Error("TLinearMinimizer::SetFunction(IMultiGenFunction)","Wrong type of function used for Linear fitter");
125 }
126
127
129  // Set the function to be minimized. The function must be a Chi2 gradient function
130  // When performing a linear fit we need the basis functions, which are the partial derivatives with respect to the parameters of the model function.
131
133  const Chi2Func * chi2func = dynamic_cast<const Chi2Func *>(&objfunc);
134  if (chi2func ==0) {
135  Error("TLinearMinimizer::SetFunction(IMultiGradFunction)","Wrong type of function used for Linear fitter");
136  return;
137  }
138  fObjFunc = chi2func;
139
140  // need to get the gradient parametric model function
141  typedef ROOT::Math::IParamMultiGradFunction ModelFunc;
142  const ModelFunc * modfunc = dynamic_cast<const ModelFunc*>( &(chi2func->ModelFunction()) );
143  assert(modfunc != 0);
144
145  fDim = chi2func->NDim(); // number of parameters
146  fNFree = fDim;
147  // get the basis functions (derivatives of the modelfunc)
148  TObjArray flist(fDim);
149  flist.SetOwner(kFALSE); // we do not want to own the list - it will be owned by the TLinearFitter class
150  for (unsigned int i = 0; i < fDim; ++i) {
151  // t.b.f: should not create TF1 classes
152  // when creating TF1 (if onother function with same name exists it is
153  // deleted since it is added in function list in gROOT
154  // fix the problem using meaniful names (difficult to re-produce)
155  BasisFunction<ModelFunc > bf(*modfunc,i);
156  TUUID u;
157  std::string fname = "_LinearMinimimizer_BasisFunction_" +
158  std::string(u.AsString() );
159  TF1 * f = new TF1(fname.c_str(),ROOT::Math::ParamFunctor(bf),0,1,0,1,TF1::EAddToList::kNo);
161  }
162
163  // create TLinearFitter (do it now because olny now now the coordinate dimensions)
164  if (fFitter) delete fFitter; // reset by deleting previous copy
165  fFitter = new TLinearFitter( static_cast<const ModelFunc::BaseFunc&>(*modfunc).NDim() );
166
167  fFitter->StoreData(fRobust); // need a copy of data in case of robust fitting
168
169  fFitter->SetBasisFunctions(&flist);
170
171  // get the fitter data
172  const ROOT::Fit::BinData & data = chi2func->Data();
173  // add the data but not store them
174  for (unsigned int i = 0; i < data.Size(); ++i) {
175  double y = 0;
176  const double * x = data.GetPoint(i,y);
177  double ey = 1;
178  if (! data.Opt().fErrors1) {
179  ey = data.Error(i);
180  }
181  // interface should take a double *
182  fFitter->AddPoint( const_cast<double *>(x) , y, ey);
183  }
184
185 }
186
187 bool TLinearMinimizer::SetFixedVariable(unsigned int ivar, const std::string & /* name */ , double val) {
188  // set a fixed variable.
189  if (!fFitter) return false;
190  fFitter->FixParameter(ivar, val);
191  return true;
192 }
193
195  // find directly the minimum of the chi2 function
196  // solving the linear equation. Use TVirtualFitter::Eval.
197
198  if (fFitter == 0 || fObjFunc == 0) return false;
199
200  int iret = 0;
201  if (!fRobust)
202  iret = fFitter->Eval();
203  else {
204  // robust fitting - get h parameter using tolerance (t.b. improved)
205  double h = Tolerance();
206  if (PrintLevel() > 0)
207  std::cout << "TLinearMinimizer: Robust fitting with h = " << h << std::endl;
208  iret = fFitter->EvalRobust(h);
209  }
210  fStatus = iret;
211
212  if (iret != 0) {
213  Warning("Minimize","TLinearFitter failed in finding the solution");
214  return false;
215  }
216
217
218  // get parameter values
219  fParams.resize( fDim);
220  // no error available for robust fitting
221  if (!fRobust) fErrors.resize( fDim);
222  for (unsigned int i = 0; i < fDim; ++i) {
223  fParams[i] = fFitter->GetParameter( i);
224  if (!fRobust) fErrors[i] = fFitter->GetParError( i );
225  }
226  fCovar.resize(fDim*fDim);
227  double * cov = fFitter->GetCovarianceMatrix();
228
229  if (!fRobust && cov) std::copy(cov,cov+fDim*fDim,fCovar.begin() );
230
231  // calculate chi2 value
232
233  fMinVal = (*fObjFunc)(&fParams.front());
234
235  return true;
236
237 }
238
239
240 // } // end namespace Fit
241
242 // } // end namespace ROOT
243
unsigned int Size() const
return number of fit points
Definition: BinData.h:447
virtual void StoreData(Bool_t store)
Interface (abstract class) for multi-dimensional functions providing a gradient calculation.
Definition: IFunction.h:322
std::vector< double > fErrors
An array of TObjects.
Definition: TObjArray.h:39
virtual void FixParameter(Int_t ipar)
Fixes paramter #ipar at its current value.
The Linear Fitter - For fitting functions that are LINEAR IN PARAMETERS.
std::vector< double > fParams
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
TH1 * h
Definition: legend2.C:5
const Bool_t kFALSE
Definition: Rtypes.h:92
TLinearFitter * fFitter
virtual Double_t * GetCovarianceMatrix() const
Returns covariance matrix.
Minimizer()
Default constructor.
Definition: Minimizer.h:93
unsigned int fNFree
int PrintLevel() const
minimizer configuration parameters
Definition: Minimizer.h:419
TLinearMinimizer class: minimizer implementation based on TMinuit.
const double * GetPoint(unsigned int ipoint, double &value) const
retrieve at the same time a pointer to the coordinate data and the fit value More efficient than call...
Definition: BinData.h:304
This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDent...
Definition: TUUID.h:44
Double_t x[n]
Definition: legend1.C:17
TLinearMinimizer & operator=(const TLinearMinimizer &rhs)
Assignment operator.
std::vector< double > fCovar
virtual void SetFunction(const ROOT::Math::IMultiGenFunction &func)
set the fit model function
double Error(unsigned int ipoint) const
return error on the value for the given fit point Safe (but slower) method returning correctly the er...
Definition: BinData.h:249
void Error(const char *location, const char *msgfmt,...)
double Tolerance() const
absolute tolerance
Definition: Minimizer.h:428
Chi2FCN class for binnned fits using the least square methods.
Definition: Chi2FCN.h:68
virtual Double_t GetParameter(Int_t ipar) const
IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a ...
const ROOT::Math::IMultiGradFunction * fObjFunc
virtual Int_t EvalRobust(Double_t h=-1)
Finds the parameters of the fitted function in case data contains outliers.
const DataOptions & Opt() const
Definition: DataVector.h:97
Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y ...
Definition: BinData.h:61
void Warning(const char *location, const char *msgfmt,...)
virtual void SetBasisFunctions(TObjArray *functions)
set the basis functions in case the fitting function is not set directly The TLinearFitter will manag...
virtual Int_t Eval()
Perform the fit and evaluate the parameters Returns 0 if the fit is ok, 1 if there are errors...
TLinearMinimizer(int type=0)
Default constructor.
#define ClassImp(name)
Definition: Rtypes.h:279
double f(double x)
virtual Double_t GetParError(Int_t ipar) const
Returns the error of parameter #ipar.
Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition ...
int type
Definition: TGX11.cxx:120
Double_t y[n]
Definition: legend1.C:17
Double_t ey[n]
Definition: legend1.C:17
virtual bool Minimize()
method to perform the minimization
const char * AsString() const
Return UUID as string. Copy string immediately since it will be reused.
Definition: TUUID.cxx:537
bool fRobust
return reference to the objective function virtual const ROOT::Math::IGenFunction & Function() const;...
1-Dim function class
Definition: TF1.h:149
Param Functor class for Multidimensional functions.
Definition: ParamFunctor.h:209