ROOT logo
// @(#)root/fumili:$Id: TFumiliMinimizer.h 26866 2008-12-12 10:50:07Z moneta $
// Author: L. Moneta Wed Oct 25 16:28:55 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class TFumiliMinimizer

#ifndef ROOT_TFumiliMinimizer
#define ROOT_TFumiliMinimizer

#ifndef ROOT_Math_Minimizer
#include "Math/Minimizer.h"
#endif

#ifndef ROOT_Math_FitMethodFunction
#include "Math/FitMethodFunction.h"
#endif

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif

class TFumili; 



// namespace ROOT { 

//    namespace Math { 

//       class BasicFitMethodFunction<ROOT::Math::IMultiGenFunction>; 
//       class BasicFitMethodFunction<ROOT::Math::IMultiGradFunction>; 

//    }
// }

 

/** 
   TFumiliMinimizer class: minimizer implementation based on TFumili.
*/ 
class TFumiliMinimizer  : public ROOT::Math::Minimizer {

public: 

   /** 
      Default constructor (an argument is needed by plug-in manager)
   */ 
   TFumiliMinimizer (int dummy=0 );


   /** 
      Destructor (no operations)
   */ 
   ~TFumiliMinimizer (); 

private:
   // usually copying is non trivial, so we make this unaccessible

   /** 
      Copy constructor
   */ 
   TFumiliMinimizer(const TFumiliMinimizer &); 

   /** 
      Assignment operator
   */ 
   TFumiliMinimizer & operator = (const TFumiliMinimizer & rhs); 

public: 

   /// set the function to minimize
   virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func); 

   /// set the function to minimize
   virtual void SetFunction(const ROOT::Math::IMultiGradFunction & func); 

   /// set free variable 
   virtual bool SetVariable(unsigned int ivar, const std::string & name, double val, double step); 

   /// set upper/lower limited variable (override if minimizer supports them )
   virtual bool SetLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double /* lower */, double /* upper */); 

#ifdef LATER
   /// set lower limit variable  (override if minimizer supports them )
   virtual bool SetLowerLimitedVariable(unsigned int  ivar , const std::string & name , double val , double step , double lower );
   /// set upper limit variable (override if minimizer supports them )
   virtual bool SetUpperLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double upper );
#endif

   /// set fixed variable (override if minimizer supports them )
   virtual bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */);  

   /// set the value of an existing variable 
   virtual bool SetVariableValue(unsigned int ivar, double val );

   /// method to perform the minimization
   virtual  bool Minimize(); 

   /// return minimum function value
   virtual double MinValue() const { return fMinVal; } 

   /// return expected distance reached from the minimum
   virtual double Edm() const { return fEdm; }

   /// return  pointer to X values at the minimum 
   virtual const double *  X() const { return &fParams.front(); }

   /// return pointer to gradient values at the minimum 
   virtual const double *  MinGradient() const { return 0; } // not available 

   /// number of function calls to reach the minimum 
   virtual unsigned int NCalls() const { return 0; } 

   /// this is <= Function().NDim() which is the total 
   /// number of variables (free+ constrained ones) 
   virtual unsigned int NDim() const { return fDim; }   

   /// number of free variables (real dimension of the problem) 
   /// this is <= Function().NDim() which is the total 
   virtual unsigned int NFree() const { return fNFree; }  

   /// minimizer provides error and error matrix
   virtual bool ProvidesError() const { return true; } 

   /// return errors at the minimum 
   virtual const double * Errors() const { return  &fErrors.front(); }

   /** return covariance matrices elements 
       if the variable is fixed the matrix is zero
       The ordering of the variables is the same as in errors
   */ 
   virtual double CovMatrix(unsigned int i, unsigned int j) const { 
      return fCovar[i + fDim* j]; 
   }


   

protected: 

   /// implementation of FCN for Fumili
   static void Fcn( int &, double * , double & f, double * , int);
   /// implementation of FCN for Fumili when user provided gradient is used
   //static void FcnGrad( int &, double * g, double & f, double * , int);

   /// static function implementing the evaluation of the FCN (it uses static instance fgFumili)
   static double EvaluateFCN(const double * x, double * g); 

private: 


   unsigned int fDim; 
   unsigned int fNFree;
   double fMinVal;
   double fEdm; 
   std::vector<double> fParams;
   std::vector<double> fErrors;
   std::vector<double> fCovar; 

   TFumili * fFumili; 

   // need to have a static copy of the function 
   //NOTE: This is NOT thread safe.
   static ROOT::Math::FitMethodFunction * fgFunc;
   static ROOT::Math::FitMethodGradFunction * fgGradFunc;

   static TFumili * fgFumili; // static instance (used by fcn function) 

   ClassDef(TFumiliMinimizer,1)  //Implementation of Minimizer interface using TFumili 

}; 



#endif /* ROOT_TFumiliMinimizer */
 TFumiliMinimizer.h:1
 TFumiliMinimizer.h:2
 TFumiliMinimizer.h:3
 TFumiliMinimizer.h:4
 TFumiliMinimizer.h:5
 TFumiliMinimizer.h:6
 TFumiliMinimizer.h:7
 TFumiliMinimizer.h:8
 TFumiliMinimizer.h:9
 TFumiliMinimizer.h:10
 TFumiliMinimizer.h:11
 TFumiliMinimizer.h:12
 TFumiliMinimizer.h:13
 TFumiliMinimizer.h:14
 TFumiliMinimizer.h:15
 TFumiliMinimizer.h:16
 TFumiliMinimizer.h:17
 TFumiliMinimizer.h:18
 TFumiliMinimizer.h:19
 TFumiliMinimizer.h:20
 TFumiliMinimizer.h:21
 TFumiliMinimizer.h:22
 TFumiliMinimizer.h:23
 TFumiliMinimizer.h:24
 TFumiliMinimizer.h:25
 TFumiliMinimizer.h:26
 TFumiliMinimizer.h:27
 TFumiliMinimizer.h:28
 TFumiliMinimizer.h:29
 TFumiliMinimizer.h:30
 TFumiliMinimizer.h:31
 TFumiliMinimizer.h:32
 TFumiliMinimizer.h:33
 TFumiliMinimizer.h:34
 TFumiliMinimizer.h:35
 TFumiliMinimizer.h:36
 TFumiliMinimizer.h:37
 TFumiliMinimizer.h:38
 TFumiliMinimizer.h:39
 TFumiliMinimizer.h:40
 TFumiliMinimizer.h:41
 TFumiliMinimizer.h:42
 TFumiliMinimizer.h:43
 TFumiliMinimizer.h:44
 TFumiliMinimizer.h:45
 TFumiliMinimizer.h:46
 TFumiliMinimizer.h:47
 TFumiliMinimizer.h:48
 TFumiliMinimizer.h:49
 TFumiliMinimizer.h:50
 TFumiliMinimizer.h:51
 TFumiliMinimizer.h:52
 TFumiliMinimizer.h:53
 TFumiliMinimizer.h:54
 TFumiliMinimizer.h:55
 TFumiliMinimizer.h:56
 TFumiliMinimizer.h:57
 TFumiliMinimizer.h:58
 TFumiliMinimizer.h:59
 TFumiliMinimizer.h:60
 TFumiliMinimizer.h:61
 TFumiliMinimizer.h:62
 TFumiliMinimizer.h:63
 TFumiliMinimizer.h:64
 TFumiliMinimizer.h:65
 TFumiliMinimizer.h:66
 TFumiliMinimizer.h:67
 TFumiliMinimizer.h:68
 TFumiliMinimizer.h:69
 TFumiliMinimizer.h:70
 TFumiliMinimizer.h:71
 TFumiliMinimizer.h:72
 TFumiliMinimizer.h:73
 TFumiliMinimizer.h:74
 TFumiliMinimizer.h:75
 TFumiliMinimizer.h:76
 TFumiliMinimizer.h:77
 TFumiliMinimizer.h:78
 TFumiliMinimizer.h:79
 TFumiliMinimizer.h:80
 TFumiliMinimizer.h:81
 TFumiliMinimizer.h:82
 TFumiliMinimizer.h:83
 TFumiliMinimizer.h:84
 TFumiliMinimizer.h:85
 TFumiliMinimizer.h:86
 TFumiliMinimizer.h:87
 TFumiliMinimizer.h:88
 TFumiliMinimizer.h:89
 TFumiliMinimizer.h:90
 TFumiliMinimizer.h:91
 TFumiliMinimizer.h:92
 TFumiliMinimizer.h:93
 TFumiliMinimizer.h:94
 TFumiliMinimizer.h:95
 TFumiliMinimizer.h:96
 TFumiliMinimizer.h:97
 TFumiliMinimizer.h:98
 TFumiliMinimizer.h:99
 TFumiliMinimizer.h:100
 TFumiliMinimizer.h:101
 TFumiliMinimizer.h:102
 TFumiliMinimizer.h:103
 TFumiliMinimizer.h:104
 TFumiliMinimizer.h:105
 TFumiliMinimizer.h:106
 TFumiliMinimizer.h:107
 TFumiliMinimizer.h:108
 TFumiliMinimizer.h:109
 TFumiliMinimizer.h:110
 TFumiliMinimizer.h:111
 TFumiliMinimizer.h:112
 TFumiliMinimizer.h:113
 TFumiliMinimizer.h:114
 TFumiliMinimizer.h:115
 TFumiliMinimizer.h:116
 TFumiliMinimizer.h:117
 TFumiliMinimizer.h:118
 TFumiliMinimizer.h:119
 TFumiliMinimizer.h:120
 TFumiliMinimizer.h:121
 TFumiliMinimizer.h:122
 TFumiliMinimizer.h:123
 TFumiliMinimizer.h:124
 TFumiliMinimizer.h:125
 TFumiliMinimizer.h:126
 TFumiliMinimizer.h:127
 TFumiliMinimizer.h:128
 TFumiliMinimizer.h:129
 TFumiliMinimizer.h:130
 TFumiliMinimizer.h:131
 TFumiliMinimizer.h:132
 TFumiliMinimizer.h:133
 TFumiliMinimizer.h:134
 TFumiliMinimizer.h:135
 TFumiliMinimizer.h:136
 TFumiliMinimizer.h:137
 TFumiliMinimizer.h:138
 TFumiliMinimizer.h:139
 TFumiliMinimizer.h:140
 TFumiliMinimizer.h:141
 TFumiliMinimizer.h:142
 TFumiliMinimizer.h:143
 TFumiliMinimizer.h:144
 TFumiliMinimizer.h:145
 TFumiliMinimizer.h:146
 TFumiliMinimizer.h:147
 TFumiliMinimizer.h:148
 TFumiliMinimizer.h:149
 TFumiliMinimizer.h:150
 TFumiliMinimizer.h:151
 TFumiliMinimizer.h:152
 TFumiliMinimizer.h:153
 TFumiliMinimizer.h:154
 TFumiliMinimizer.h:155
 TFumiliMinimizer.h:156
 TFumiliMinimizer.h:157
 TFumiliMinimizer.h:158
 TFumiliMinimizer.h:159
 TFumiliMinimizer.h:160
 TFumiliMinimizer.h:161
 TFumiliMinimizer.h:162
 TFumiliMinimizer.h:163
 TFumiliMinimizer.h:164
 TFumiliMinimizer.h:165
 TFumiliMinimizer.h:166
 TFumiliMinimizer.h:167
 TFumiliMinimizer.h:168
 TFumiliMinimizer.h:169
 TFumiliMinimizer.h:170
 TFumiliMinimizer.h:171
 TFumiliMinimizer.h:172
 TFumiliMinimizer.h:173
 TFumiliMinimizer.h:174
 TFumiliMinimizer.h:175
 TFumiliMinimizer.h:176
 TFumiliMinimizer.h:177
 TFumiliMinimizer.h:178
 TFumiliMinimizer.h:179
 TFumiliMinimizer.h:180
 TFumiliMinimizer.h:181