// @(#)root/minuit2:$Id$
// Author: L. Moneta Wed Oct 18 11:48:00 2006

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

// Header file for class Minuit2Minimizer

#ifndef ROOT_Minuit2_Minuit2Minimizer
#define ROOT_Minuit2_Minuit2Minimizer

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

#ifndef ROOT_Minuit2_MnUserParameterState
#include "Minuit2/MnUserParameterState.h"
#endif

#ifndef ROOT_Math_IFunctionfwd
#include "Math/IFunctionfwd.h"
#endif



namespace ROOT {

   namespace Minuit2 {

      class ModularFunctionMinimizer;
      class FCNBase;
      class FunctionMinimum;
      class MnTraceObject;

      // enumeration specifying the type of Minuit2 minimizers
      enum EMinimizerType {
         kMigrad,
         kSimplex,
         kCombined,
         kScan,
         kFumili
      };

   }

   namespace Minuit2 {
//_____________________________________________________________________________________________________
/**
   Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for
   Minuit2 minimization algorithm.
   In ROOT it can be instantiated using the plug-in manager (plug-in "Minuit2")
   Using a string  (used by the plugin manager) or via an enumeration
   an one can set all the possible minimization algorithms (Migrad, Simplex, Combined, Scan and Fumili).
*/
class Minuit2Minimizer : public ROOT::Math::Minimizer {

public:

   /**
      Default constructor
   */
   Minuit2Minimizer (ROOT::Minuit2::EMinimizerType type = ROOT::Minuit2::kMigrad);

   /**
      Constructor with a char (used by PM)
   */
   Minuit2Minimizer (const char *  type);

   /**
      Destructor (no operations)
   */
   virtual ~Minuit2Minimizer ();

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

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

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

public:

   // clear resources (parameters) for consecutives minimizations
   virtual void Clear();

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

   /// set gradient 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 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 );
   /// 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 */);
   /// set fixed variable (override if minimizer supports them )
   virtual bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */);
   /// set variable
   virtual bool SetVariableValue(unsigned int ivar, double val);
   // set variable values
   virtual bool SetVariableValues(const double * val);
   /// set the step size of an already existing variable
   virtual bool SetVariableStepSize(unsigned int ivar, double step );
   /// set the lower-limit of an already existing variable
   virtual bool SetVariableLowerLimit(unsigned int ivar, double lower);
   /// set the upper-limit of an already existing variable
   virtual bool SetVariableUpperLimit(unsigned int ivar, double upper);
   /// set the limits of an already existing variable
   virtual bool SetVariableLimits(unsigned int ivar, double lower, double upper);
   /// fix an existing variable
   virtual bool FixVariable(unsigned int ivar);
   /// release an existing variable
   virtual bool ReleaseVariable(unsigned int ivar);
   /// query if an existing variable is fixed (i.e. considered constant in the minimization)
   /// note that by default all variables are not fixed
   virtual bool IsFixedVariable(unsigned int ivar)  const;
   /// get variable settings in a variable object (like ROOT::Fit::ParamsSettings)
   virtual bool GetVariableSettings(unsigned int ivar, ROOT::Fit::ParameterSettings & varObj) const;
   /// get name of variables (override if minimizer support storing of variable names)
   virtual std::string VariableName(unsigned int ivar) const;
   /// get index of variable given a variable given a name
   /// return -1 if variable is not found
   virtual int VariableIndex(const std::string & name) const;

   /**
       method to perform the minimization.
       Return false in case the minimization did not converge. In this case a
       status code different than zero is set
       (retrieved by the derived method Minimizer::Status() )"

       status = 1    : Covariance was made pos defined
       status = 2    : Hesse is invalid
       status = 3    : Edm is above max
       status = 4    : Reached call limit
       status = 5    : Any other failure
   */
   virtual  bool Minimize();

   /// return minimum function value
   virtual double MinValue() const { return fState.Fval(); }

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

   /// return  pointer to X values at the minimum
   virtual const double *  X() const;

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

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

   /// 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 fState.VariableParameters(); }

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

   /// return errors at the minimum
   virtual const double * Errors() const;

   /**
       return covariance matrix elements
       if the variable is fixed or const the value is zero
       The ordering of the variables is the same as in errors and parameter value.
       This is different from the direct interface of Minuit2 or TMinuit where the
       values were obtained only to variable parameters
   */
   virtual double CovMatrix(unsigned int i, unsigned int j) const;


   /**
       Fill the passed array with the  covariance matrix elements
       if the variable is fixed or const the value is zero.
       The array will be filled as cov[i *ndim + j]
       The ordering of the variables is the same as in errors and parameter value.
       This is different from the direct interface of Minuit2 or TMinuit where the
       values were obtained only to variable parameters
   */
   virtual bool GetCovMatrix(double * cov) const;

   /**
       Fill the passed array with the Hessian matrix elements
       The Hessian matrix is the matrix of the second derivatives
       and is the inverse of the covariance matrix
       If the variable is fixed or const the values for that variables are zero.
       The array will be filled as h[i *ndim + j]
   */
   virtual bool GetHessianMatrix(double * h) const;


   /**
      return the status of the covariance matrix
       status = -1 :  not available (inversion failed or Hesse failed)
       status =  0 : available but not positive defined
       status =  1 : covariance only approximate
       status =  2 : full matrix but forced pos def
       status =  3 : full accurate matrix

    */
   virtual int CovMatrixStatus() const;
   /**
      return correlation coefficient between variable i and j.
      If the variable is fixed or const the return value is zero
    */
   virtual double Correlation(unsigned int i, unsigned int j ) const;

   /**
      get global correlation coefficient for the variable i. This is a number between zero and one which gives
      the correlation between the i-th variable  and that linear combination of all other variables which
      is most strongly correlated with i.
      If the variable is fixed or const the return value is zero
    */
   virtual double GlobalCC(unsigned int i) const;

   /**
      get the minos error for parameter i, return false if Minos failed
      A minimizaiton must be performed befre, return false if no minimization has been done
      In case of Minos failed the status error is updated as following
      status += 10 * minosStatus where the minos status is:
       status = 1    : maximum number of function calls exceeded when running for lower error
       status = 2    : maximum number of function calls exceeded when running for upper error
       status = 3    : new minimum found when running for lower error
       status = 4    : new minimum found when running for upper error
       status = 5    : any other failure

   */
   virtual bool GetMinosError(unsigned int i, double & errLow, double & errUp, int = 0);

   /**
      scan a parameter i around the minimum. A minimization must have been done before,
      return false if it is not the case
    */
   virtual bool Scan(unsigned int i, unsigned int & nstep, double * x, double * y, double xmin = 0, double xmax = 0);

   /**
      find the contour points (xi,xj) of the function for parameter i and j around the minimum
      The contour will be find for value of the function = Min + ErrorUp();
    */
   virtual bool Contour(unsigned int i, unsigned int j, unsigned int & npoints, double *xi, double *xj);


   /**
      perform a full calculation of the Hessian matrix for error calculation
      If a valid minimum exists the calculation is done on the minimum point otherwise is performed
      in the current set values of parameters
      Status code of minimizer is updated according to the following convention (in case Hesse failed)
      status += 100*hesseStatus where hesse status is:
      status = 1 : hesse failed
      status = 2 : matrix inversion failed
      status = 3 : matrix is not pos defined
    */
   virtual bool Hesse();


   /// return reference to the objective function
   ///virtual const ROOT::Math::IGenFunction & Function() const;

   /// print result of minimization
   virtual void PrintResults();

   /// set an object to trace operation for each iteration
   /// The object muust implement operator() (unsigned int, MinimumState & state)
   void SetTraceObject(MnTraceObject & obj);

   /// set storage level   = 1 : store all iteration states (default)
   ///                     = 0 : store only first and last state to save memory
   void SetStorageLevel(int level);

   /// return the minimizer state (containing values, step size , etc..)
   const ROOT::Minuit2::MnUserParameterState & State() { return fState; }

protected:

   // protected function for accessing the internal Minuit2 object. Needed for derived classes

   virtual const ROOT::Minuit2::ModularFunctionMinimizer * GetMinimizer() const { return fMinimizer; }

   virtual void SetMinimizer( ROOT::Minuit2::ModularFunctionMinimizer * m)  { fMinimizer = m; }

   void SetMinimizerType( ROOT::Minuit2::EMinimizerType type);

   virtual const  ROOT::Minuit2::FCNBase * GetFCN() const { return fMinuitFCN; }

   /// examine the minimum result
   bool ExamineMinimum(const ROOT::Minuit2::FunctionMinimum & min);

private:

   unsigned int fDim;       // dimension of the function to be minimized
   bool fUseFumili;

   ROOT::Minuit2::MnUserParameterState fState;
   // std::vector<ROOT::Minuit2::MinosError> fMinosErrors;
   ROOT::Minuit2::ModularFunctionMinimizer * fMinimizer;
   ROOT::Minuit2::FCNBase * fMinuitFCN;
   ROOT::Minuit2::FunctionMinimum * fMinimum;
   mutable std::vector<double> fValues;
   mutable std::vector<double> fErrors;

};

   } // end namespace Fit

} // end namespace ROOT



#endif /* ROOT_Minuit2_Minuit2Minimizer */
 Minuit2Minimizer.h:1
 Minuit2Minimizer.h:2
 Minuit2Minimizer.h:3
 Minuit2Minimizer.h:4
 Minuit2Minimizer.h:5
 Minuit2Minimizer.h:6
 Minuit2Minimizer.h:7
 Minuit2Minimizer.h:8
 Minuit2Minimizer.h:9
 Minuit2Minimizer.h:10
 Minuit2Minimizer.h:11
 Minuit2Minimizer.h:12
 Minuit2Minimizer.h:13
 Minuit2Minimizer.h:14
 Minuit2Minimizer.h:15
 Minuit2Minimizer.h:16
 Minuit2Minimizer.h:17
 Minuit2Minimizer.h:18
 Minuit2Minimizer.h:19
 Minuit2Minimizer.h:20
 Minuit2Minimizer.h:21
 Minuit2Minimizer.h:22
 Minuit2Minimizer.h:23
 Minuit2Minimizer.h:24
 Minuit2Minimizer.h:25
 Minuit2Minimizer.h:26
 Minuit2Minimizer.h:27
 Minuit2Minimizer.h:28
 Minuit2Minimizer.h:29
 Minuit2Minimizer.h:30
 Minuit2Minimizer.h:31
 Minuit2Minimizer.h:32
 Minuit2Minimizer.h:33
 Minuit2Minimizer.h:34
 Minuit2Minimizer.h:35
 Minuit2Minimizer.h:36
 Minuit2Minimizer.h:37
 Minuit2Minimizer.h:38
 Minuit2Minimizer.h:39
 Minuit2Minimizer.h:40
 Minuit2Minimizer.h:41
 Minuit2Minimizer.h:42
 Minuit2Minimizer.h:43
 Minuit2Minimizer.h:44
 Minuit2Minimizer.h:45
 Minuit2Minimizer.h:46
 Minuit2Minimizer.h:47
 Minuit2Minimizer.h:48
 Minuit2Minimizer.h:49
 Minuit2Minimizer.h:50
 Minuit2Minimizer.h:51
 Minuit2Minimizer.h:52
 Minuit2Minimizer.h:53
 Minuit2Minimizer.h:54
 Minuit2Minimizer.h:55
 Minuit2Minimizer.h:56
 Minuit2Minimizer.h:57
 Minuit2Minimizer.h:58
 Minuit2Minimizer.h:59
 Minuit2Minimizer.h:60
 Minuit2Minimizer.h:61
 Minuit2Minimizer.h:62
 Minuit2Minimizer.h:63
 Minuit2Minimizer.h:64
 Minuit2Minimizer.h:65
 Minuit2Minimizer.h:66
 Minuit2Minimizer.h:67
 Minuit2Minimizer.h:68
 Minuit2Minimizer.h:69
 Minuit2Minimizer.h:70
 Minuit2Minimizer.h:71
 Minuit2Minimizer.h:72
 Minuit2Minimizer.h:73
 Minuit2Minimizer.h:74
 Minuit2Minimizer.h:75
 Minuit2Minimizer.h:76
 Minuit2Minimizer.h:77
 Minuit2Minimizer.h:78
 Minuit2Minimizer.h:79
 Minuit2Minimizer.h:80
 Minuit2Minimizer.h:81
 Minuit2Minimizer.h:82
 Minuit2Minimizer.h:83
 Minuit2Minimizer.h:84
 Minuit2Minimizer.h:85
 Minuit2Minimizer.h:86
 Minuit2Minimizer.h:87
 Minuit2Minimizer.h:88
 Minuit2Minimizer.h:89
 Minuit2Minimizer.h:90
 Minuit2Minimizer.h:91
 Minuit2Minimizer.h:92
 Minuit2Minimizer.h:93
 Minuit2Minimizer.h:94
 Minuit2Minimizer.h:95
 Minuit2Minimizer.h:96
 Minuit2Minimizer.h:97
 Minuit2Minimizer.h:98
 Minuit2Minimizer.h:99
 Minuit2Minimizer.h:100
 Minuit2Minimizer.h:101
 Minuit2Minimizer.h:102
 Minuit2Minimizer.h:103
 Minuit2Minimizer.h:104
 Minuit2Minimizer.h:105
 Minuit2Minimizer.h:106
 Minuit2Minimizer.h:107
 Minuit2Minimizer.h:108
 Minuit2Minimizer.h:109
 Minuit2Minimizer.h:110
 Minuit2Minimizer.h:111
 Minuit2Minimizer.h:112
 Minuit2Minimizer.h:113
 Minuit2Minimizer.h:114
 Minuit2Minimizer.h:115
 Minuit2Minimizer.h:116
 Minuit2Minimizer.h:117
 Minuit2Minimizer.h:118
 Minuit2Minimizer.h:119
 Minuit2Minimizer.h:120
 Minuit2Minimizer.h:121
 Minuit2Minimizer.h:122
 Minuit2Minimizer.h:123
 Minuit2Minimizer.h:124
 Minuit2Minimizer.h:125
 Minuit2Minimizer.h:126
 Minuit2Minimizer.h:127
 Minuit2Minimizer.h:128
 Minuit2Minimizer.h:129
 Minuit2Minimizer.h:130
 Minuit2Minimizer.h:131
 Minuit2Minimizer.h:132
 Minuit2Minimizer.h:133
 Minuit2Minimizer.h:134
 Minuit2Minimizer.h:135
 Minuit2Minimizer.h:136
 Minuit2Minimizer.h:137
 Minuit2Minimizer.h:138
 Minuit2Minimizer.h:139
 Minuit2Minimizer.h:140
 Minuit2Minimizer.h:141
 Minuit2Minimizer.h:142
 Minuit2Minimizer.h:143
 Minuit2Minimizer.h:144
 Minuit2Minimizer.h:145
 Minuit2Minimizer.h:146
 Minuit2Minimizer.h:147
 Minuit2Minimizer.h:148
 Minuit2Minimizer.h:149
 Minuit2Minimizer.h:150
 Minuit2Minimizer.h:151
 Minuit2Minimizer.h:152
 Minuit2Minimizer.h:153
 Minuit2Minimizer.h:154
 Minuit2Minimizer.h:155
 Minuit2Minimizer.h:156
 Minuit2Minimizer.h:157
 Minuit2Minimizer.h:158
 Minuit2Minimizer.h:159
 Minuit2Minimizer.h:160
 Minuit2Minimizer.h:161
 Minuit2Minimizer.h:162
 Minuit2Minimizer.h:163
 Minuit2Minimizer.h:164
 Minuit2Minimizer.h:165
 Minuit2Minimizer.h:166
 Minuit2Minimizer.h:167
 Minuit2Minimizer.h:168
 Minuit2Minimizer.h:169
 Minuit2Minimizer.h:170
 Minuit2Minimizer.h:171
 Minuit2Minimizer.h:172
 Minuit2Minimizer.h:173
 Minuit2Minimizer.h:174
 Minuit2Minimizer.h:175
 Minuit2Minimizer.h:176
 Minuit2Minimizer.h:177
 Minuit2Minimizer.h:178
 Minuit2Minimizer.h:179
 Minuit2Minimizer.h:180
 Minuit2Minimizer.h:181
 Minuit2Minimizer.h:182
 Minuit2Minimizer.h:183
 Minuit2Minimizer.h:184
 Minuit2Minimizer.h:185
 Minuit2Minimizer.h:186
 Minuit2Minimizer.h:187
 Minuit2Minimizer.h:188
 Minuit2Minimizer.h:189
 Minuit2Minimizer.h:190
 Minuit2Minimizer.h:191
 Minuit2Minimizer.h:192
 Minuit2Minimizer.h:193
 Minuit2Minimizer.h:194
 Minuit2Minimizer.h:195
 Minuit2Minimizer.h:196
 Minuit2Minimizer.h:197
 Minuit2Minimizer.h:198
 Minuit2Minimizer.h:199
 Minuit2Minimizer.h:200
 Minuit2Minimizer.h:201
 Minuit2Minimizer.h:202
 Minuit2Minimizer.h:203
 Minuit2Minimizer.h:204
 Minuit2Minimizer.h:205
 Minuit2Minimizer.h:206
 Minuit2Minimizer.h:207
 Minuit2Minimizer.h:208
 Minuit2Minimizer.h:209
 Minuit2Minimizer.h:210
 Minuit2Minimizer.h:211
 Minuit2Minimizer.h:212
 Minuit2Minimizer.h:213
 Minuit2Minimizer.h:214
 Minuit2Minimizer.h:215
 Minuit2Minimizer.h:216
 Minuit2Minimizer.h:217
 Minuit2Minimizer.h:218
 Minuit2Minimizer.h:219
 Minuit2Minimizer.h:220
 Minuit2Minimizer.h:221
 Minuit2Minimizer.h:222
 Minuit2Minimizer.h:223
 Minuit2Minimizer.h:224
 Minuit2Minimizer.h:225
 Minuit2Minimizer.h:226
 Minuit2Minimizer.h:227
 Minuit2Minimizer.h:228
 Minuit2Minimizer.h:229
 Minuit2Minimizer.h:230
 Minuit2Minimizer.h:231
 Minuit2Minimizer.h:232
 Minuit2Minimizer.h:233
 Minuit2Minimizer.h:234
 Minuit2Minimizer.h:235
 Minuit2Minimizer.h:236
 Minuit2Minimizer.h:237
 Minuit2Minimizer.h:238
 Minuit2Minimizer.h:239
 Minuit2Minimizer.h:240
 Minuit2Minimizer.h:241
 Minuit2Minimizer.h:242
 Minuit2Minimizer.h:243
 Minuit2Minimizer.h:244
 Minuit2Minimizer.h:245
 Minuit2Minimizer.h:246
 Minuit2Minimizer.h:247
 Minuit2Minimizer.h:248
 Minuit2Minimizer.h:249
 Minuit2Minimizer.h:250
 Minuit2Minimizer.h:251
 Minuit2Minimizer.h:252
 Minuit2Minimizer.h:253
 Minuit2Minimizer.h:254
 Minuit2Minimizer.h:255
 Minuit2Minimizer.h:256
 Minuit2Minimizer.h:257
 Minuit2Minimizer.h:258
 Minuit2Minimizer.h:259
 Minuit2Minimizer.h:260
 Minuit2Minimizer.h:261
 Minuit2Minimizer.h:262
 Minuit2Minimizer.h:263
 Minuit2Minimizer.h:264
 Minuit2Minimizer.h:265
 Minuit2Minimizer.h:266
 Minuit2Minimizer.h:267
 Minuit2Minimizer.h:268
 Minuit2Minimizer.h:269
 Minuit2Minimizer.h:270
 Minuit2Minimizer.h:271
 Minuit2Minimizer.h:272
 Minuit2Minimizer.h:273
 Minuit2Minimizer.h:274
 Minuit2Minimizer.h:275
 Minuit2Minimizer.h:276
 Minuit2Minimizer.h:277
 Minuit2Minimizer.h:278
 Minuit2Minimizer.h:279
 Minuit2Minimizer.h:280
 Minuit2Minimizer.h:281
 Minuit2Minimizer.h:282
 Minuit2Minimizer.h:283
 Minuit2Minimizer.h:284
 Minuit2Minimizer.h:285
 Minuit2Minimizer.h:286
 Minuit2Minimizer.h:287
 Minuit2Minimizer.h:288
 Minuit2Minimizer.h:289
 Minuit2Minimizer.h:290
 Minuit2Minimizer.h:291
 Minuit2Minimizer.h:292
 Minuit2Minimizer.h:293
 Minuit2Minimizer.h:294
 Minuit2Minimizer.h:295
 Minuit2Minimizer.h:296
 Minuit2Minimizer.h:297
 Minuit2Minimizer.h:298
 Minuit2Minimizer.h:299
 Minuit2Minimizer.h:300
 Minuit2Minimizer.h:301
 Minuit2Minimizer.h:302
 Minuit2Minimizer.h:303
 Minuit2Minimizer.h:304
 Minuit2Minimizer.h:305
 Minuit2Minimizer.h:306
 Minuit2Minimizer.h:307
 Minuit2Minimizer.h:308
 Minuit2Minimizer.h:309
 Minuit2Minimizer.h:310
 Minuit2Minimizer.h:311
 Minuit2Minimizer.h:312
 Minuit2Minimizer.h:313
 Minuit2Minimizer.h:314
 Minuit2Minimizer.h:315
 Minuit2Minimizer.h:316
 Minuit2Minimizer.h:317
 Minuit2Minimizer.h:318
 Minuit2Minimizer.h:319
 Minuit2Minimizer.h:320
 Minuit2Minimizer.h:321
 Minuit2Minimizer.h:322
 Minuit2Minimizer.h:323
 Minuit2Minimizer.h:324
 Minuit2Minimizer.h:325
 Minuit2Minimizer.h:326
 Minuit2Minimizer.h:327
 Minuit2Minimizer.h:328
 Minuit2Minimizer.h:329
 Minuit2Minimizer.h:330