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

   virtual ~HybridMinimizer (); 

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
   virtual void Clear();

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

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

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

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

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

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

   virtual  bool Minimize(); 

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

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

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

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

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

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

   virtual bool ProvidesError() const { return true; } 

   virtual const double * Errors() const; 

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


   virtual bool GetCovMatrix(double * cov) const;  

   virtual bool GetHessianMatrix(double * h) const;  


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

   virtual double GlobalCC(unsigned int i) const;

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

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

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

   
   virtual bool Hesse();



   virtual void PrintResults(); 

   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