class ROOT::Minuit2::Minuit2Minimizer: public ROOT::Math::Minimizer

      Default constructor

      Constructor with a char (used by PM)

      Destructor (no operations)

 usually copying is non trivial, so we make this unaccessible

      Copy constructor

 clear resources (parameters) for consecutives minimizations

 set the function to minimize

 set gradient the function to minimize

 set free variable

 set lower limit variable  (override if minimizer supports them )

 set upper limit variable (override if minimizer supports them )

 set upper/lower limited variable (override if minimizer supports them )

 set fixed variable (override if minimizer supports them )

 set variable

 set variable values

 set the step size of an already existing variable

 set the lower-limit of an already existing variable

 set the upper-limit of an already existing variable

 set the limits of an already existing variable

 fix an existing variable

 release an existing variable

 query if an existing variable is fixed (i.e. considered constant in the minimization)
 note that by default all variables are not fixed

 get variable settings in a variable object (like ROOT::Fit::ParamsSettings)

 get name of variables (override if minimizer support storing of variable names)

 get index of variable given a variable given a name
 return -1 if variable is not found

       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

 return minimum function value

 return expected distance reached from the minimum

 return  pointer to X values at the minimum

 return pointer to gradient values at the minimum

 number of function calls to reach the minimum

 this is <= Function().NDim() which is the total
 number of variables (free+ constrained ones)

 number of free variables (real dimension of the problem)
 this is <= Function().NDim() which is the total

 minimizer provides error and error matrix

 return errors at the minimum

       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

       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

       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]

      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

      return correlation coefficient between variable i and j.
      If the variable is fixed or const the return value is zero

      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

      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

      scan a parameter i around the minimum. A minimization must have been done before,
      return false if it is not the case

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

      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

 return reference to the objective function
virtual const ROOT::Math::IGenFunction & Function() const;
 print result of minimization

 set an object to trace operation for each iteration
 The object muust implement operator() (unsigned int, MinimumState & state)

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

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

 examine the minimum result