PSFitter::HybridMinimizer Class Reference

#include <HybridMinimizer.h>

Inheritance diagram for PSFitter::HybridMinimizer:

Public Types
enum	EMinimizerType {   kMigrad, kSimplex, kCombined, kScan,   kFumili }

Public Member Functions
void	Clear () override
bool	Contour (unsigned int i, unsigned int j, unsigned int &npoints, double *xi, double *xj) override
double	Correlation (unsigned int i, unsigned int j) const override
double	CovMatrix (unsigned int i, unsigned int j) const override
int	CovMatrixStatus () const override
double	Edm () const override
	return expected distance reached from the minimum More...
const double *	Errors () const override
	return errors at the minimum More...
bool	GetCovMatrix (double *cov) const override
bool	GetHessianMatrix (double *h) const override
bool	GetMinosError (unsigned int i, double &errLow, double &errUp, int=0) override
double	GlobalCC (unsigned int i) const override
bool	Hesse () override
	HybridMinimizer (const char *type)
	HybridMinimizer (EMinimizerType type=kMigrad)
const double *	MinGradient () const override
	return pointer to gradient values at the minimum More...
bool	Minimize () override
double	MinValue () const override
	return minimum function value More...
unsigned int	NCalls () const override
	number of function calls to reach the minimum More...
unsigned int	NDim () const override
unsigned int	NFree () const override
void	PrintResults () override
	print result of minimization More...
bool	ProvidesError () const override
	minimizer provides error and error matrix More...
bool	Scan (unsigned int i, unsigned int &nstep, double *x, double *y, double xmin=0, double xmax=0) override
bool	SetFixedVariable (unsigned int, const std::string &, double) override
	set fixed variable (override if minimizer supports them ) More...
void	SetFunction (const ROOT::Math::IMultiGenFunction &func) override
	set the function to minimize More...
void	SetFunction (const ROOT::Math::IMultiGradFunction &func) override
	set gradient the function to minimize More...
bool	SetLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double, double) override
	set upper/lower limited variable (override if minimizer supports them ) More...
bool	SetLowerLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double lower) override
	set lower limit variable (override if minimizer supports them ) More...
void	SetMinimizerType (EMinimizerType type)
bool	SetUpperLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double upper) override
	set upper limit variable (override if minimizer supports them ) More...
bool	SetVariable (unsigned int ivar, const std::string &name, double val, double step) override
	set free variable More...
bool	SetVariableValue (unsigned int ivar, double val) override
	set variable More...
bool	SetVariableValues (const double *val) override
const ROOT::Minuit2::MnUserParameterState &	State ()
	return the minimizer state (containing values, step size , etc..) More...
int	VariableIndex (const std::string &name) const override
std::string	VariableName (unsigned int ivar) const override
	get name of variables (override if minimizer support storing of variable names) More...
const double *	X () const override
	return pointer to X values at the minimum More...
	~HybridMinimizer () override

Protected Member Functions
bool	ExamineMinimum (const ROOT::Minuit2::FunctionMinimum &min)
	examine the minimum result More...
virtual const ROOT::Minuit2::FCNBase *	GetFCN () const
virtual const ROOT::Minuit2::ModularFunctionMinimizer *	GetMinimizer () const
virtual void	SetMinimizer (ROOT::Minuit2::ModularFunctionMinimizer *m)

Private Member Functions
	HybridMinimizer (const HybridMinimizer &)
HybridMinimizer &	operator= (const HybridMinimizer &rhs)

Private Attributes
unsigned int	fDim
std::vector< double >	fErrors
ROOT::Minuit2::ModularFunctionMinimizer *	fMinimizer
ROOT::Minuit2::FunctionMinimum *	fMinimum
ROOT::Minuit2::FCNBase *	fMinuitFCN
ROOT::Minuit2::MnUserParameterState	fState
bool	fUseFumili
std::vector< double >	fValues

Detailed Description

Definition at line 44 of file HybridMinimizer.h.

Member Enumeration Documentation

EMinimizerType

enum PSFitter::HybridMinimizer::EMinimizerType

Enumerator
kMigrad
kSimplex
kCombined
kScan
kFumili

Definition at line 46 of file HybridMinimizer.h.

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

Constructor & Destructor Documentation

HybridMinimizer() [1/3]

PSFitter::HybridMinimizer::HybridMinimizer

(

EMinimizerType

type = kMigrad

)

Default constructor

Definition at line 73 of file HybridMinimizer.cc.

      : Minimizer(), fDim(0), fMinimizer(nullptr), fMinuitFCN(nullptr), fMinimum(nullptr) {

HybridMinimizer() [2/3]

PSFitter::HybridMinimizer::HybridMinimizer

(

const char *

type

)

Constructor with a char (used by PM)

Definition at line 79 of file HybridMinimizer.cc.

                                                            {
    // Set  minimizer algorithm type

~HybridMinimizer()

PSFitter::HybridMinimizer::~HybridMinimizer ( )

override

Destructor (no operations)

Definition at line 132 of file HybridMinimizer.cc.

                                                          : ROOT::Math::Minimizer() {
    // Implementation of copy constructor.

HybridMinimizer() [3/3]

PSFitter::HybridMinimizer::HybridMinimizer ( const HybridMinimizer &  )

private

Copy constructor

Definition at line 142 of file HybridMinimizer.cc.

                                                                        {
    // Implementation of assignment operator.

Member Function Documentation

Clear()

void PSFitter::HybridMinimizer::Clear ( )

override

Definition at line 153 of file HybridMinimizer.cc.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

Contour()

bool PSFitter::HybridMinimizer::Contour ( unsigned int  i, unsigned int  j, unsigned int &  npoints, double *  xi, double *  xj  )

override

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

Definition at line 863 of file HybridMinimizer.cc.

                             {
      MN_ERROR_MSG2("HybridMinimizer::Contour", " no function minimum existing. Must minimize function before");
      return false;
    }
 
    if (!fMinimum->IsValid()) {
      MN_ERROR_MSG2("HybridMinimizer::Contour", "Invalid function minimum");
      return false;
    }
    assert(fMinuitFCN);
 
    fMinuitFCN->SetErrorDef(ErrorDef());
    // if error def has been changed update it in FunctionMinimum
    if (ErrorDef() != fMinimum->Up())
      fMinimum->SetErrorDef(ErrorDef());
 
    // switch off Minuit2 printing (for level of  0,1)
    int prev_level = (PrintLevel() <= 1) ? TurnOffPrintInfoLevel() : -2;
 
    MnPrint::SetLevel(PrintLevel());
 
    // set the precision if needed
    if (Precision() > 0)
      fState.SetPrecision(Precision());
 
    // eventually one should specify tolerance in contours
    MnContours contour(*fMinuitFCN, *fMinimum, Strategy());
 
    if (prev_level > -2)
      RestoreGlobalPrintLevel(prev_level);
 
    std::vector<std::pair<double, double> > result = contour(ipar, jpar, npoints);
    if (result.size() != npoints) {
      MN_ERROR_MSG2("HybridMinimizer::Contour", " Invalid result from MnContours");
      return false;
    }
    for (unsigned int i = 0; i < npoints; ++i) {
      x[i] = result[i].first;
      y[i] = result[i].second;
    }
 
    return true;
  }
 
  bool HybridMinimizer::Hesse() {
    // find Hessian (full second derivative calculations)

Correlation()

double PSFitter::HybridMinimizer::Correlation ( unsigned int  i, unsigned int  j  ) const

override

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

Definition at line 618 of file HybridMinimizer.cc.

                                                       {
    // get global correlation coefficient for the parameter i. This is a number between zero and one which gives

CovMatrix()

double PSFitter::HybridMinimizer::CovMatrix ( unsigned int  i, unsigned int  j  ) const

override

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

Definition at line 545 of file HybridMinimizer.cc.

                                                      {
    // get value of covariance matrices

CovMatrixStatus()

int PSFitter::HybridMinimizer::CovMatrixStatus ( ) const

override

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

Definition at line 978 of file HybridMinimizer.cc.

                  {
      // case a function minimum  is available
      if (fMinimum->HasAccurateCovar())
        return 3;
      else if (fMinimum->HasMadePosDefCovar())
        return 2;
      else if (fMinimum->HasValidCovariance())
        return 1;
      else if (fMinimum->HasCovariance())
        return 0;
      return -1;
    } else {
      // case fMinimum is not available - use state information
      return fState.CovarianceStatus();
    }
    return 0;
  }
 
}  // namespace PSFitter

References fMinimum.

Edm()

double PSFitter::HybridMinimizer::Edm ( ) const

inlineoverride

return expected distance reached from the minimum

Definition at line 133 of file HybridMinimizer.h.

{ return fState.Edm(); }

Errors()

const double * PSFitter::HybridMinimizer::Errors ( ) const

override

return errors at the minimum

Definition at line 524 of file HybridMinimizer.cc.

                                            {
      const MinuitParameter &par = paramsObj[i];
      if (par.IsFixed() || par.IsConst())
        fErrors[i] = 0;
      else
        fErrors[i] = par.Error();
    }
 
    return &fErrors.front();
  }
 
  double HybridMinimizer::CovMatrix(unsigned int i, unsigned int j) const {
    // get value of covariance matrices (transform from external to internal indices)

References fErrors, and mps_fire::i.

ExamineMinimum()

bool PSFitter::HybridMinimizer::ExamineMinimum ( const ROOT::Minuit2::FunctionMinimum &  min )

protected

examine the minimum result

study the function minimum

Definition at line 408 of file HybridMinimizer.cc.

                         {
      /*      
      const std::vector<ROOT::Minuit2::MinimumState>& iterationStates = min.States();
      std::cout << "Number of iterations " << iterationStates.size() << std::endl;
      for (unsigned int i = 0; i <  iterationStates.size(); ++i) {
         //std::cout << iterationStates[i] << std::endl;                                                                       
         const ROOT::Minuit2::MinimumState & st =  iterationStates[i];
         std::cout << "----------> Iteration " << i << std::endl;
         int pr = std::cout.precision(12);
         std::cout << "            FVAL = " << st.Fval() << " Edm = " << st.Edm() << " Nfcn = " << st.NFcn() << std::endl;
         std::cout.precision(pr);
         std::cout << "            Error matrix change = " << st.Error().Dcovar() << std::endl;
         std::cout << "            Parameters : ";
         // need to transform from internal to external 
         for (int j = 0; j < st.size() ; ++j) std::cout << " p" << j << " = " << fState.Int2ext( j, st.Vec()(j) );
         std::cout << std::endl;
      }
*/
    }
 
    fStatus = 0;
    std::string txt;
    if (min.HasMadePosDefCovar()) {
      txt = "Covar was made pos def";
      fStatus = 1;
    }
    if (min.HesseFailed()) {
      txt = "Hesse is not valid";
      fStatus = 2;
    }
    if (min.IsAboveMaxEdm()) {
      txt = "Edm is above max";
      fStatus = 3;
    }
    if (min.HasReachedCallLimit()) {
      txt = "Reached call limit";
      fStatus = 4;
    }
 
    bool validMinimum = min.IsValid();
    if (validMinimum) {
      // print a warning message in case something is not ok
      if (fStatus != 0 && debugLevel > 0)
        MN_INFO_MSG2("HybridMinimizer::Minimize", txt);
    } else {
      // minimum is not valid when state is not valid and edm is over max or has passed call limits
      if (fStatus == 0) {
        // this should not happen
        txt = "unknown failure";
        fStatus = 5;
      }
      std::string msg = "Minimization did NOT converge, " + txt;
      MN_INFO_MSG2("HybridMinimizer::Minimize", msg);
    }
 
    if (debugLevel >= 1)
      PrintResults();
    return validMinimum;
  }
 
  void HybridMinimizer::PrintResults() {
    // print results of minimization

GetCovMatrix()

bool PSFitter::HybridMinimizer::GetCovMatrix ( double *  cov ) const

override

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

Definition at line 560 of file HybridMinimizer.cc.

                                            {
      if (fState.Parameter(i).IsFixed() || fState.Parameter(i).IsConst()) {
        for (unsigned int j = 0; j < fDim; ++j) {
          cov[i * fDim + j] = 0;
        }
      } else {
        unsigned int l = fState.IntOfExt(i);
        for (unsigned int j = 0; j < fDim; ++j) {
          // could probably speed up this loop (if needed)
          int k = i * fDim + j;
          if (fState.Parameter(j).IsFixed() || fState.Parameter(j).IsConst())
            cov[k] = 0;
          else {
            // need to transform from external to internal indices)
            // for taking care of the removed fixed row/columns in the Minuit2 representation
            unsigned int m = fState.IntOfExt(j);
            cov[k] = fState.Covariance()(l, m);
          }
        }
      }
    }
    return true;
  }
 
  bool HybridMinimizer::GetHessianMatrix(double *hess) const {
    // get value of Hessian matrix

References fDim, fState, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, and visualization-live-secondInstance_cfg::m.

GetFCN()

virtual const ROOT::Minuit2::FCNBase* PSFitter::HybridMinimizer::GetFCN ( ) const

inlineprotectedvirtual

Definition at line 266 of file HybridMinimizer.h.

References fMinuitFCN.

GetHessianMatrix()

bool PSFitter::HybridMinimizer::GetHessianMatrix ( double *  h ) const

override

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]

Definition at line 588 of file HybridMinimizer.cc.

                                            {
      if (fState.Parameter(i).IsFixed() || fState.Parameter(i).IsConst()) {
        for (unsigned int j = 0; j < fDim; ++j) {
          hess[i * fDim + j] = 0;
        }
      } else {
        unsigned int l = fState.IntOfExt(i);
        for (unsigned int j = 0; j < fDim; ++j) {
          // could probably speed up this loop (if needed)
          int k = i * fDim + j;
          if (fState.Parameter(j).IsFixed() || fState.Parameter(j).IsConst())
            hess[k] = 0;
          else {
            // need to transform from external to internal indices)
            // for taking care of the removed fixed row/columns in the Minuit2 representation
            unsigned int m = fState.IntOfExt(j);
            hess[k] = fState.Hessian()(l, m);
          }
        }
      }
    }
 
    return true;
  }
 
  double HybridMinimizer::Correlation(unsigned int i, unsigned int j) const {
    // get correlation between parameter i and j

References fDim, fState, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, and visualization-live-secondInstance_cfg::m.

GetMinimizer()

virtual const ROOT::Minuit2::ModularFunctionMinimizer* PSFitter::HybridMinimizer::GetMinimizer ( ) const

inlineprotectedvirtual

Definition at line 262 of file HybridMinimizer.h.

References fMinimizer.

GetMinosError()

bool PSFitter::HybridMinimizer::GetMinosError ( unsigned int  i, double &  errLow, double &  errUp, int  runopt = 0  )

override

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

Definition at line 653 of file HybridMinimizer.cc.

                                                                        {
      return false;
    }
 
    int debugLevel = PrintLevel();
    // internal minuit messages
    MnPrint::SetLevel(debugLevel);
 
    // to run minos I need function minimum class
    // redo minimization from current state
    //    ROOT::Minuit2::FunctionMinimum min =
    //       GetMinimizer()->Minimize(*GetFCN(),fState, ROOT::Minuit2::MnStrategy(strategy), MaxFunctionCalls(), Tolerance());
    //    fState = min.UserState();
    if (fMinimum == nullptr) {
      MN_ERROR_MSG("HybridMinimizer::GetMinosErrors:  failed - no function minimum existing");
      return false;
    }
 
    if (!fMinimum->IsValid()) {
      MN_ERROR_MSG("HybridMinimizer::MINOS failed due to invalid function minimum");
      return false;
    }
 
    fMinuitFCN->SetErrorDef(ErrorDef());
    // if error def has been changed update it in FunctionMinimum
    if (ErrorDef() != fMinimum->Up())
      fMinimum->SetErrorDef(ErrorDef());
 
    // switch off Minuit2 printing
    int prev_level = (PrintLevel() <= 0) ? TurnOffPrintInfoLevel() : -2;
 
    // set the precision if needed
    if (Precision() > 0)
      fState.SetPrecision(Precision());
 
    ROOT::Minuit2::MnMinos minos(*fMinuitFCN, *fMinimum);
 
    // run MnCross
    MnCross low;
    MnCross up;
    int maxfcn = MaxFunctionCalls();
    double tol = Tolerance();
 
    //   const char * par_name = fState.Name(i);
 
    // now input tolerance for migrad calls inside Minos (MnFunctionCross)
    // before it was fixed to 0.05
    // cut off too small tolerance (they are not needed)
    tol = std::max(tol, 0.01);
 
    /*
   if (PrintLevel() >=1) { 
      // print the real number of maxfcn used (defined in MnMinos)
      int maxfcn_used = maxfcn; 
      if (maxfcn_used == 0) { 
    int nvar = fState.VariableParameters();
    maxfcn_used = 2*(nvar+1)*(200 + 100*nvar + 5*nvar*nvar);
      }
//      std::cout << "HybridMinimizer::GetMinosError for parameter " << i << "  " << par_name
//                << " using max-calls " << maxfcn_used << ", tolerance " << tol << std::endl; 
   }
   */
 
    if (runLower)
      low = minos.Loval(i, maxfcn, tol);
    if (runUpper)
      up = minos.Upval(i, maxfcn, tol);
 
    ROOT::Minuit2::MinosError me(i, fMinimum->UserState().Value(i), low, up);
 
    if (prev_level > -2)
      RestoreGlobalPrintLevel(prev_level);
 
    // debug result of Minos
    // print error message in Minos
 
    if (debugLevel >= 1) {
      /*
      if (runLower) { 
         if (!me.LowerValid() )  
            std::cout << "Minos:  Invalid lower error for parameter " << par_name << std::endl; 
         if(me.AtLowerLimit()) 
            std::cout << "Minos:  Parameter : " << par_name << "  is at Lower limit."<<std::endl;
         if(me.AtLowerMaxFcn())
            std::cout << "Minos:  Maximum number of function calls exceeded when running for lower error" <<std::endl;   
         if(me.LowerNewMin() )
            std::cout << "Minos:  New Minimum found while running Minos for lower error" <<std::endl;     
 
         if (debugLevel > 1)  std::cout << "Minos: Lower error for parameter " << par_name << "  :  " << me.Lower() << std::endl; 
 
      }
      if (runUpper) {          
         if (!me.UpperValid() )  
            std::cout << "Minos:  Invalid upper error for parameter " << par_name << std::endl; 
         if(me.AtUpperLimit()) 
            std::cout << "Minos:  Parameter " << par_name << " is at Upper limit."<<std::endl;
         if(me.AtUpperMaxFcn())
            std::cout << "Minos:  Maximum number of function calls exceeded when running for upper error" <<std::endl;   
         if(me.UpperNewMin() )
            std::cout << "Minos:  New Minimum found while running Minos for upper error" <<std::endl;              
 
         if (debugLevel > 1)  std::cout << "Minos: Upper error for parameter " << par_name << "  :  " << me.Upper() << std::endl;
      }
*/
    }
 
    bool lowerInvalid = (runLower && !me.LowerValid());
    bool upperInvalid = (runUpper && !me.UpperValid());
    int mstatus = 0;
    if (lowerInvalid || upperInvalid) {
      // set status accroding to bit
      // bit 1:  lower invalid Minos errors
      // bit 2:  uper invalid Minos error
      // bit 3:   invalid because max FCN
      // bit 4 : invalid because a new minimum has been found
      if (lowerInvalid) {
        mstatus |= 1;
        if (me.AtLowerMaxFcn())
          mstatus |= 4;
        if (me.LowerNewMin())
          mstatus |= 8;
      }
      if (upperInvalid) {
        mstatus |= 3;
        if (me.AtUpperMaxFcn())
          mstatus |= 4;
        if (me.UpperNewMin())
          mstatus |= 8;
      }
      //std::cout << "Error running Minos for parameter " << i << std::endl;
      fStatus += 10 * mstatus;
    }
 
    errLow = me.Lower();
    errUp = me.Upper();
 
    bool isValid = (runLower && me.LowerValid()) || (runUpper && me.UpperValid());
    return isValid;
  }
 
  bool HybridMinimizer::Scan(unsigned int ipar, unsigned int &nstep, double *x, double *y, double xmin, double xmax) {
    // scan a parameter (variable) around the minimum value

GlobalCC()

double PSFitter::HybridMinimizer::GlobalCC ( unsigned int  i ) const

override

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

Definition at line 637 of file HybridMinimizer.cc.

                                                                                               {
    // return the minos error for parameter i

Hesse()

bool PSFitter::HybridMinimizer::Hesse ( )

override

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

Definition at line 910 of file HybridMinimizer.cc.

                     {
      MN_ERROR_MSG2("HybridMinimizer::Hesse", "FCN function has not been set");
      return false;
    }
 
    int strategy = Strategy();
    int maxfcn = MaxFunctionCalls();
 
    // switch off Minuit2 printing
    int prev_level = (PrintLevel() <= 0) ? TurnOffPrintInfoLevel() : -2;
 
    MnPrint::SetLevel(PrintLevel());
 
    // set the precision if needed
    if (Precision() > 0)
      fState.SetPrecision(Precision());
 
    ROOT::Minuit2::MnHesse hesse(strategy);
 
    // case when function minimum exists
    if (fMinimum) {
      // run hesse and function minimum will be updated with Hesse result
      hesse(*fMinuitFCN, *fMinimum, maxfcn);
      fState = fMinimum->UserState();
    }
 
    else {
      // run Hesse on point stored in current state (independent of function minimum validity)
      // (x == 0)
      fState = hesse(*fMinuitFCN, fState, maxfcn);
    }
 
    if (prev_level > -2)
      RestoreGlobalPrintLevel(prev_level);
 
    if (PrintLevel() >= 3) {
      //      std::cout << "State returned from Hesse " << std::endl;
      //      std::cout << fState << std::endl;
    }
 
    if (!fState.HasCovariance()) {
      // if false means error is not valid and this is due to a failure in Hesse
      if (PrintLevel() > 0)
        MN_INFO_MSG2("HybridMinimizer::Hesse", "Hesse failed ");
      // update minimizer error status
      int hstatus = 4;
      // information on error state can be retrieved only if fMinimum is available
      if (fMinimum) {
        if (fMinimum->Error().HesseFailed())
          hstatus = 1;
        if (fMinimum->Error().InvertFailed())
          hstatus = 2;
        else if (!(fMinimum->Error().IsPosDef()))
          hstatus = 3;
      }
      fStatus += 100 * hstatus;
      return false;
    }
 
    return true;
  }
 
  int HybridMinimizer::CovMatrixStatus() const {
    // return status of covariance matrix

MinGradient()

const double* PSFitter::HybridMinimizer::MinGradient ( ) const

inlineoverride

return pointer to gradient values at the minimum

Definition at line 139 of file HybridMinimizer.h.

{ return nullptr; }  // not available in Minuit2

Minimize()

bool PSFitter::HybridMinimizer::Minimize ( )

override

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

Definition at line 298 of file HybridMinimizer.cc.

                     {
      MN_ERROR_MSG2("HybridMinimizer::Minimize", "FCN function has not been set");
      return false;
    }
 
    assert(GetMinimizer() != nullptr);
 
    // delete result of previous minimization
    if (fMinimum)
      delete fMinimum;
    fMinimum = nullptr;
 
    int maxfcn = MaxFunctionCalls();
    double tol = Tolerance();
    int strategyLevel = Strategy();
    fMinuitFCN->SetErrorDef(ErrorDef());
 
    /*
   if (PrintLevel() >=1) { 
      // print the real number of maxfcn used (defined in ModularFuncitonMinimizer)
      int maxfcn_used = maxfcn; 
      if (maxfcn_used == 0) { 
    int nvar = fState.VariableParameters();
    maxfcn_used = 200 + 100*nvar + 5*nvar*nvar;
      }      
//      std::cout << "HybridMinimizer: Minimize with max-calls " << maxfcn_used 
//                << " convergence for edm < " << tol << " strategy " 
//                << strategyLevel << std::endl; 
   }
   */
 
    // internal minuit messages
    MnPrint::SetLevel(PrintLevel());
 
    // switch off Minuit2 printing
    int prev_level = (PrintLevel() <= 0) ? TurnOffPrintInfoLevel() : -2;
 
    // set the precision if needed
    if (Precision() > 0)
      fState.SetPrecision(Precision());
 
    // set strategy and add extra options if needed
    ROOT::Minuit2::MnStrategy strategy(strategyLevel);
    ROOT::Math::IOptions *minuit2Opt = ROOT::Math::MinimizerOptions::FindDefault("Minuit2");
    if (minuit2Opt) {
      // set extra strategy options
      int nGradCycles = strategy.GradientNCycles();
      int nHessCycles = strategy.HessianNCycles();
      int nHessGradCycles = strategy.HessianGradientNCycles();
 
      double gradTol = strategy.GradientTolerance();
      double gradStepTol = strategy.GradientStepTolerance();
      double hessStepTol = strategy.HessianStepTolerance();
      double hessG2Tol = strategy.HessianG2Tolerance();
 
      minuit2Opt->GetValue("GradientNCycles", nGradCycles);
      minuit2Opt->GetValue("HessianNCycles", nHessCycles);
      minuit2Opt->GetValue("HessianGradientNCycles", nHessGradCycles);
 
      minuit2Opt->GetValue("GradientTolerance", gradTol);
      minuit2Opt->GetValue("GradientStepTolerance", gradStepTol);
      minuit2Opt->GetValue("HessianStepTolerance", hessStepTol);
      minuit2Opt->GetValue("HessianG2Tolerance", hessG2Tol);
 
      strategy.SetGradientNCycles(nGradCycles);
      strategy.SetHessianNCycles(nHessCycles);
      strategy.SetHessianGradientNCycles(nHessGradCycles);
 
      strategy.SetGradientTolerance(gradTol);
      strategy.SetGradientStepTolerance(gradStepTol);
      strategy.SetHessianStepTolerance(hessStepTol);
      strategy.SetHessianG2Tolerance(hessStepTol);
 
      if (PrintLevel() > 0) {
        //         std::cout << "HybridMinimizer::Minuit  - Changing default stratgey options" << std::endl;
        minuit2Opt->Print();
      }
    }
 
    const ROOT::Minuit2::FCNGradientBase *gradFCN = dynamic_cast<const ROOT::Minuit2::FCNGradientBase *>(fMinuitFCN);
    if (gradFCN != nullptr) {
      // use gradient
      //SetPrintLevel(3);
      ROOT::Minuit2::FunctionMinimum min = GetMinimizer()->Minimize(*gradFCN, fState, strategy, maxfcn, tol);
      fMinimum = new ROOT::Minuit2::FunctionMinimum(min);
    } else {
      ROOT::Minuit2::FunctionMinimum min = GetMinimizer()->Minimize(*GetFCN(), fState, strategy, maxfcn, tol);
      fMinimum = new ROOT::Minuit2::FunctionMinimum(min);
    }
 
    // check if Hesse needs to be run
    if (fMinimum->IsValid() && IsValidError() && fMinimum->State().Error().Dcovar() != 0) {
      // run Hesse (Hesse will add results in the last state of fMinimum
      ROOT::Minuit2::MnHesse hesse(strategy);
      hesse(*fMinuitFCN, *fMinimum, maxfcn);
    }
 
    // -2 is the highest low invalid value for gErrorIgnoreLevel
    if (prev_level > -2)
      RestoreGlobalPrintLevel(prev_level);
 
    fState = fMinimum->UserState();
    bool ok = ExamineMinimum(*fMinimum);
    //fMinimum = 0;
    return ok;
  }
 
  bool HybridMinimizer::ExamineMinimum(const ROOT::Minuit2::FunctionMinimum &min) {

Referenced by PulseShapeFitOOTPileupCorrection::fit().

MinValue()

double PSFitter::HybridMinimizer::MinValue ( ) const

inlineoverride

return minimum function value

Definition at line 130 of file HybridMinimizer.h.

{ return fState.Fval(); }

Referenced by PulseShapeFitOOTPileupCorrection::fit().

NCalls()

unsigned int PSFitter::HybridMinimizer::NCalls ( ) const

inlineoverride

number of function calls to reach the minimum

Definition at line 142 of file HybridMinimizer.h.

{ return fState.NFcn(); }

NDim()

unsigned int PSFitter::HybridMinimizer::NDim ( ) const

inlineoverride

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

Definition at line 146 of file HybridMinimizer.h.

{ return fDim; }

NFree()

unsigned int PSFitter::HybridMinimizer::NFree ( ) const

inlineoverride

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

Definition at line 150 of file HybridMinimizer.h.

{ return fState.VariableParameters(); }

operator=()

HybridMinimizer & PSFitter::HybridMinimizer::operator= ( const HybridMinimizer &  rhs )

private

Assignment operator

Definition at line 146 of file HybridMinimizer.cc.

                              {
    // delete the state in case of consecutive minimizations

PrintResults()

void PSFitter::HybridMinimizer::PrintResults ( )

override

print result of minimization

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

Definition at line 473 of file HybridMinimizer.cc.

                             {
      // valid minimum
      /*
      std::cout << "HybridMinimizer : Valid minimum - status = " << fStatus  << std::endl; 
      int pr = std::cout.precision(18);
      std::cout << "FVAL  = " << fState.Fval() << std::endl;
      std::cout << "Edm   = " << fState.Edm() << std::endl;
      std::cout.precision(pr);
      std::cout << "Nfcn  = " << fState.NFcn() << std::endl;
      for (unsigned int i = 0; i < fState.MinuitParameters().size(); ++i) {
         const MinuitParameter & par = fState.Parameter(i); 
         std::cout << par.Name() << "\t  = " << par.Value() << "\t ";
         if (par.IsFixed() )      std::cout << "(fixed)" << std::endl;
         else if (par.IsConst() ) std::cout << "(const)" << std::endl;
         else if (par.HasLimits() ) 
            std::cout << "+/-  " << par.Error() << "\t(limited)"<< std::endl; 
         else 
            std::cout << "+/-  " << par.Error() << std::endl; 
      }
*/
    } else {
      /*
      std::cout << "HybridMinimizer : Invalid Minimum - status = " << fStatus << std::endl; 
      std::cout << "FVAL  = " << fState.Fval() << std::endl;
      std::cout << "Edm   = " << fState.Edm() << std::endl;
      std::cout << "Nfcn  = " << fState.NFcn() << std::endl;
*/
    }
  }
 
  const double *HybridMinimizer::X() const {
    // return values at minimum

ProvidesError()

bool PSFitter::HybridMinimizer::ProvidesError ( ) const

inlineoverride

minimizer provides error and error matrix

Definition at line 153 of file HybridMinimizer.h.

{ return true; }

Scan()

bool PSFitter::HybridMinimizer::Scan ( unsigned int  i, unsigned int &  nstep, double *  x, double *  y, double  xmin = 0, double  xmax = 0  )

override

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

Definition at line 806 of file HybridMinimizer.cc.

                     {
      MN_ERROR_MSG2("HybridMinimizer::Scan", " Function must be set before using Scan");
      return false;
    }
 
    if (ipar > fState.MinuitParameters().size()) {
      MN_ERROR_MSG2("HybridMinimizer::Scan", " Invalid number. Minimizer variables must be set before using Scan");
      return false;
    }
 
    // switch off Minuit2 printing
    int prev_level = (PrintLevel() <= 0) ? TurnOffPrintInfoLevel() : -2;
 
    MnPrint::SetLevel(PrintLevel());
 
    // set the precision if needed
    if (Precision() > 0)
      fState.SetPrecision(Precision());
 
    MnParameterScan scan(*fMinuitFCN, fState.Parameters());
    double amin = scan.Fval();  // fcn value of the function before scan
 
    // first value is param value
    std::vector<std::pair<double, double> > result = scan(ipar, nstep - 1, xmin, xmax);
 
    if (prev_level > -2)
      RestoreGlobalPrintLevel(prev_level);
 
    if (result.size() != nstep) {
      MN_ERROR_MSG2("HybridMinimizer::Scan", " Invalid result from MnParameterScan");
      return false;
    }
    // sort also the returned points in x
    std::sort(result.begin(), result.end());
 
    for (unsigned int i = 0; i < nstep; ++i) {
      x[i] = result[i].first;
      y[i] = result[i].second;
    }
 
    // what to do if a new minimum has been found ?
    // use that as new minimum
    if (scan.Fval() < amin) {
      if (PrintLevel() > 0)
        MN_INFO_MSG2("HybridMinimizer::Scan", "A new minimum has been found");
      fState.SetValue(ipar, scan.Parameters().Value(ipar));
    }
 
    return true;
  }
 
  bool HybridMinimizer::Contour(unsigned int ipar, unsigned int jpar, unsigned int &npoints, double *x, double *y) {
    // contour plot for parameter i and j

SetFixedVariable()

bool PSFitter::HybridMinimizer::SetFixedVariable ( unsigned int  ivar, const std::string &  name, double  val  )

override

set fixed variable (override if minimizer supports them )

Definition at line 219 of file HybridMinimizer.cc.

                                                 : 0.1;
    if (!SetVariable(ivar, name, val, step)) {
      ivar = fState.Index(name);
    }
    fState.Fix(ivar);
    return true;
  }
 
  std::string HybridMinimizer::VariableName(unsigned int ivar) const {
    // return the variable name

References fState, and Skims_PA_cff::name.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

SetFunction() [1/2]

void PSFitter::HybridMinimizer::SetFunction ( const ROOT::Math::IMultiGenFunction &  func )

override

set the function to minimize

Definition at line 262 of file HybridMinimizer.cc.

                     {
      fMinuitFCN = new ROOT::Minuit2::FCNAdapter<ROOT::Math::IMultiGenFunction>(func, ErrorDef());
    } else {
      // for Fumili the fit method function interface is required
      const ROOT::Math::FitMethodFunction *fcnfunc = dynamic_cast<const ROOT::Math::FitMethodFunction *>(&func);
      if (!fcnfunc) {
        MN_ERROR_MSG("HybridMinimizer: Wrong Fit method function for Fumili");
        return;
      }
      fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodFunction>(*fcnfunc, fDim, ErrorDef());
    }
  }
 
  void HybridMinimizer::SetFunction(const ROOT::Math::IMultiGradFunction &func) {
    // set function to be minimized

References fMinuitFCN, and TrackCollections2monitor_cff::func.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

SetFunction() [2/2]

void PSFitter::HybridMinimizer::SetFunction ( const ROOT::Math::IMultiGradFunction &  func )

override

set gradient the function to minimize

Definition at line 280 of file HybridMinimizer.cc.

                     {
      fMinuitFCN = new ROOT::Minuit2::FCNGradAdapter<ROOT::Math::IMultiGradFunction>(func, ErrorDef());
    } else {
      // for Fumili the fit method function interface is required
      const ROOT::Math::FitMethodGradFunction *fcnfunc = dynamic_cast<const ROOT::Math::FitMethodGradFunction *>(&func);
      if (!fcnfunc) {
        MN_ERROR_MSG("HybridMinimizer: Wrong Fit method function for Fumili");
        return;
      }
      fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodGradFunction>(*fcnfunc, fDim, ErrorDef());
    }
  }
 
  bool HybridMinimizer::Minimize() {
    // perform the minimization

References fMinuitFCN, and TrackCollections2monitor_cff::func.

SetLimitedVariable()

bool PSFitter::HybridMinimizer::SetLimitedVariable ( unsigned int  ivar, const std::string &  name, double  val, double  step, double  lower, double  upper  )

override

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

Definition at line 210 of file HybridMinimizer.cc.

                                                                                             {
    // add a fixed variable

Referenced by PulseShapeFitOOTPileupCorrection::fit().

SetLowerLimitedVariable()

bool PSFitter::HybridMinimizer::SetLowerLimitedVariable ( unsigned int  ivar, const std::string &  name, double  val, double  step, double  lower  )

override

set lower limit variable (override if minimizer supports them )

Definition at line 192 of file HybridMinimizer.cc.

                                                                                       {

SetMinimizer()

virtual void PSFitter::HybridMinimizer::SetMinimizer ( ROOT::Minuit2::ModularFunctionMinimizer *  m )

inlineprotectedvirtual

Definition at line 264 of file HybridMinimizer.h.

References fMinimizer, and visualization-live-secondInstance_cfg::m.

Referenced by SetMinimizerType().

SetMinimizerType()

void PSFitter::HybridMinimizer::SetMinimizerType

(

EMinimizerType

type

)

Definition at line 100 of file HybridMinimizer.cc.

                  {
      case kMigrad:
        //std::cout << "HybridMinimizer: minimize using MIGRAD " << std::endl;
        SetMinimizer(new ROOT::Minuit2::VariableMetricMinimizer());
        return;
      case kSimplex:
        //std::cout << "HybridMinimizer: minimize using SIMPLEX " << std::endl;
        SetMinimizer(new ROOT::Minuit2::SimplexMinimizer());
        return;
      case kCombined:
        SetMinimizer(new ROOT::Minuit2::CombinedMinimizer());
        return;
      case kScan:
        SetMinimizer(new ROOT::Minuit2::ScanMinimizer());
        return;
      case kFumili:
        SetMinimizer(new ROOT::Minuit2::FumiliMinimizer());
        fUseFumili = true;
        return;
      default:
        //migrad minimizer
        SetMinimizer(new ROOT::Minuit2::VariableMetricMinimizer());
    }
  }
 
  HybridMinimizer::~HybridMinimizer() {
    // Destructor implementation.

References fUseFumili, kCombined, kFumili, kMigrad, kScan, kSimplex, and SetMinimizer().

Referenced by PulseShapeFitOOTPileupCorrection::fit().

SetUpperLimitedVariable()

bool PSFitter::HybridMinimizer::SetUpperLimitedVariable ( unsigned int  ivar, const std::string &  name, double  val, double  step, double  upper  )

override

set upper limit variable (override if minimizer supports them )

Definition at line 201 of file HybridMinimizer.cc.

                                                                                                     {

SetVariable()

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

override

set free variable

Definition at line 164 of file HybridMinimizer.cc.

                   {
      std::string txtmsg = "Parameter " + name + "  has zero or invalid step size - consider it as constant ";
      MN_INFO_MSG2("HybridMinimizer::SetVariable", txtmsg);
      fState.Add(name, val);
    } else
      fState.Add(name, val, step);
 
    unsigned int minuit2Index = fState.Index(name);
    if (minuit2Index != ivar) {
      std::string txtmsg("Wrong index used for the variable " + name);
      MN_INFO_MSG2("HybridMinimizer::SetVariable", txtmsg);
      MN_INFO_VAL2("HybridMinimizer::SetVariable", minuit2Index);
      return false;
    }
    fState.RemoveLimits(ivar);
 
    return true;
  }
 
  bool HybridMinimizer::SetLowerLimitedVariable(
      unsigned int ivar, const std::string &name, double val, double step, double lower) {

References fState, Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, and heppy_batch::val.

SetVariableValue()

bool PSFitter::HybridMinimizer::SetVariableValue ( unsigned int  ivar, double  val  )

override

set variable

Definition at line 244 of file HybridMinimizer.cc.

                                                         {
    // set value for variable ivar (only for existing parameters)

SetVariableValues()

bool PSFitter::HybridMinimizer::SetVariableValues ( const double *  val )

override

Definition at line 252 of file HybridMinimizer.cc.

                                                                         {
    // set function to be minimized

State()

const ROOT::Minuit2::MnUserParameterState& PSFitter::HybridMinimizer::State ( )

inline

return the minimizer state (containing values, step size , etc..)

Definition at line 255 of file HybridMinimizer.h.

VariableIndex()

int PSFitter::HybridMinimizer::VariableIndex ( const std::string &  name ) const

override

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

Definition at line 238 of file HybridMinimizer.cc.

                                                                      {
    // set value for variable ivar (only for existing parameters)

VariableName()

std::string PSFitter::HybridMinimizer::VariableName ( unsigned int  ivar ) const

override

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

Definition at line 231 of file HybridMinimizer.cc.

                                                                {
    // return the variable index

X()

const double * PSFitter::HybridMinimizer::X ( ) const

override

return pointer to X values at the minimum

Definition at line 507 of file HybridMinimizer.cc.

                                            {
      fValues[i] = paramsObj[i].Value();
    }
 
    return &fValues.front();
  }
 
  const double *HybridMinimizer::Errors() const {
    // return error at minimum (set to zero for fixed and constant params)

References fValues, and mps_fire::i.

Referenced by svgfig.Curve.Sample::__repr__(), and PulseShapeFitOOTPileupCorrection::fit().

Member Data Documentation

fDim

unsigned int PSFitter::HybridMinimizer::fDim

private

Definition at line 272 of file HybridMinimizer.h.

Referenced by GetCovMatrix(), and GetHessianMatrix().

fErrors

std::vector<double> PSFitter::HybridMinimizer::fErrors

mutableprivate

Definition at line 281 of file HybridMinimizer.h.

Referenced by Errors().

fMinimizer

ROOT::Minuit2::ModularFunctionMinimizer* PSFitter::HybridMinimizer::fMinimizer

private

Definition at line 277 of file HybridMinimizer.h.

Referenced by GetMinimizer(), and SetMinimizer().

fMinimum

ROOT::Minuit2::FunctionMinimum* PSFitter::HybridMinimizer::fMinimum

private

Definition at line 279 of file HybridMinimizer.h.

Referenced by CovMatrixStatus().

fMinuitFCN

ROOT::Minuit2::FCNBase* PSFitter::HybridMinimizer::fMinuitFCN

private

Definition at line 278 of file HybridMinimizer.h.

Referenced by GetFCN(), and SetFunction().

fState

ROOT::Minuit2::MnUserParameterState PSFitter::HybridMinimizer::fState

private

Definition at line 275 of file HybridMinimizer.h.

Referenced by GetCovMatrix(), GetHessianMatrix(), SetFixedVariable(), and SetVariable().

fUseFumili

bool PSFitter::HybridMinimizer::fUseFumili

private

Definition at line 273 of file HybridMinimizer.h.

Referenced by SetMinimizerType().

fValues

std::vector<double> PSFitter::HybridMinimizer::fValues

mutableprivate

Definition at line 280 of file HybridMinimizer.h.

Referenced by X().