HybridMinimizer.h

Go to the documentation of this file.

// @(#)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 HybridMinimizer

#ifndef ROOT_Minuit2_HybridMinimizer
#define ROOT_Minuit2_HybridMinimizer

#include "Math/Minimizer.h"
#include "Minuit2/MnUserParameterState.h"
#include "Math/IFunctionfwd.h"
#include "Minuit2/MinosError.h"
#include "Minuit2/ModularFunctionMinimizer.h"
#include "Minuit2/FumiliMinimizer.h"

namespace ROOT { 

   namespace Minuit2 { 

      class ModularFunctionMinimizer; 
      class FCNBase; 
      class FunctionMinimum;

   }
}

//_____________________________________________________________________________________________________
namespace PSFitter{

class HybridMinimizer : public ROOT::Math::Minimizer {

public: 

   enum EMinimizerType { 
      kMigrad, 
      kSimplex, 
      kCombined, 
      kScan,
      kFumili
   };

   HybridMinimizer (EMinimizerType type = kMigrad); 

   HybridMinimizer (const char *  type); 

   ~HybridMinimizer () override; 

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

   HybridMinimizer(const HybridMinimizer &); 

   HybridMinimizer & operator = (const HybridMinimizer & rhs); 

public: 

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

   void SetFunction(const ROOT::Math::IMultiGenFunction & func) override; 

   void SetFunction(const ROOT::Math::IMultiGradFunction & func) override; 

   bool SetVariable(unsigned int ivar, const std::string & name, double val, double step) override; 

   bool SetLowerLimitedVariable(unsigned int  ivar , const std::string & name , double val , double step , double lower ) override;
   bool SetUpperLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double upper ) override; 
   bool SetLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double /* lower */, double /* upper */) override; 
   bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */) override;  
   bool SetVariableValue(unsigned int ivar, double val) override;
   bool SetVariableValues(const double * val) override;

   std::string VariableName(unsigned int ivar) const override;

   int VariableIndex(const std::string & name) const override;

    bool Minimize() override; 

   double MinValue() const override { return fState.Fval(); } 

   double Edm() const override { return fState.Edm(); }

   const double *  X() const override; 
 
   const double *  MinGradient() const override { return nullptr; } // not available in Minuit2 

   unsigned int NCalls() const override { return fState.NFcn(); } 

   unsigned int NDim() const override { return fDim; }   

   unsigned int NFree() const override { return fState.VariableParameters(); }  

   bool ProvidesError() const override { return true; } 

   const double * Errors() const override; 

   double CovMatrix(unsigned int i, unsigned int j) const override;  


   bool GetCovMatrix(double * cov) const override;  

   bool GetHessianMatrix(double * h) const override;  


   int CovMatrixStatus() const override;
   double Correlation(unsigned int i, unsigned int j ) const override; 

   double GlobalCC(unsigned int i) const override;

   bool GetMinosError(unsigned int i, double & errLow, double & errUp, int = 0) override; 

   bool Scan(unsigned int i, unsigned int & nstep, double * x, double * y, double xmin = 0, double xmax = 0) override; 

   bool Contour(unsigned int i, unsigned int j, unsigned int & npoints, double *xi, double *xj) override; 

   
   bool Hesse() override;



   void PrintResults() override; 

   const ROOT::Minuit2::MnUserParameterState & State() { return fState; }

   void SetMinimizerType( EMinimizerType type);

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

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

   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;

}; 

}
#endif