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 (EMinimizerType type=kMigrad)
	HybridMinimizer (const char *type)
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 45 of file HybridMinimizer.h.

Member Enumeration Documentation

EMinimizerType

enum PSFitter::HybridMinimizer::EMinimizerType

Enumerator
kMigrad
kSimplex
kCombined
kScan
kFumili

Definition at line 47 of file HybridMinimizer.h.

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

Constructor & Destructor Documentation

HybridMinimizer() [1/3]

PSFitter::HybridMinimizer::HybridMinimizer

(

EMinimizerType

type = kMigrad

)

Default constructor

Definition at line 71 of file HybridMinimizer.cc.

References SetMinimizerType().

      : Minimizer(), fDim(0), fMinimizer(nullptr), fMinuitFCN(nullptr), fMinimum(nullptr) {
    // Default constructor implementation depending on minimizer type
    SetMinimizerType(type);
  }

HybridMinimizer() [2/3]

PSFitter::HybridMinimizer::HybridMinimizer

(

const char *

type

)

Constructor with a char (used by PM)

Definition at line 77 of file HybridMinimizer.cc.

References createfilelist::int, kCombined, kFumili, kMigrad, kScan, kSimplex, SetMinimizerType(), AlCaHLTBitMon_QueryRunRegistry::string, and HcalDetIdTransform::transform().

      : Minimizer(), fDim(0), fMinimizer(nullptr), fMinuitFCN(nullptr), fMinimum(nullptr) {
    // constructor from a string

    std::string algoname(type);
    // tolower() is not an  std function (Windows)
    std::transform(algoname.begin(), algoname.end(), algoname.begin(), (int (*)(int))tolower);

    EMinimizerType algoType = kMigrad;
    if (algoname == "simplex")
      algoType = kSimplex;
    if (algoname == "minimize")
      algoType = kCombined;
    if (algoname == "scan")
      algoType = kScan;
    if (algoname == "fumili")
      algoType = kFumili;

    SetMinimizerType(algoType);
  }

~HybridMinimizer()

PSFitter::HybridMinimizer::~HybridMinimizer ( )

override

Destructor (no operations)

Definition at line 130 of file HybridMinimizer.cc.

References fMinimizer, fMinimum, and fMinuitFCN.

                                    {
    // Destructor implementation.
    if (fMinimizer)
      delete fMinimizer;
    if (fMinuitFCN)
      delete fMinuitFCN;
    if (fMinimum)
      delete fMinimum;
  }

HybridMinimizer() [3/3]

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

private

Copy constructor

Definition at line 140 of file HybridMinimizer.cc.

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

Member Function Documentation

Clear()

void PSFitter::HybridMinimizer::Clear ( )

override

Definition at line 151 of file HybridMinimizer.cc.

References fMinimum, and fState.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

                              {
    // delete the state in case of consecutive minimizations
    fState = MnUserParameterState();
    // clear also the function minimum
    if (fMinimum)
      delete fMinimum;
    fMinimum = nullptr;
  }

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 858 of file HybridMinimizer.cc.

References cms::cuda::assert(), fMinimum, fMinuitFCN, fState, mps_fire::i, METSignificanceParams_cfi::jpar, npoints, PSFitter::RestoreGlobalPrintLevel(), mps_fire::result, PSFitter::TurnOffPrintInfoLevel(), and x.

                                                                                                                 {
    // contour plot for parameter i and j
    // need a valid FunctionMinimum otherwise exits
    if (fMinimum == nullptr) {
      edm::LogError("HybridMinimizer::Contour") << " no function minimum existing. Must minimize function before";
      return false;
    }

    if (!fMinimum->IsValid()) {
      edm::LogError("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) {
      edm::LogError("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;
  }

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 613 of file HybridMinimizer.cc.

References funct::abs(), fDim, fState, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, MainPageGenerator::l, mathSSE::sqrt(), and createJobs::tmp.

                                                                          {
    // get correlation between parameter i and j
    if (i >= fDim || i >= fDim)
      return 0;
    if (!fState.HasCovariance())
      return 0;  // no info available when minimization has failed
    if (fState.Parameter(i).IsFixed() || fState.Parameter(i).IsConst())
      return 0;
    if (fState.Parameter(j).IsFixed() || fState.Parameter(j).IsConst())
      return 0;
    unsigned int k = fState.IntOfExt(i);
    unsigned int l = fState.IntOfExt(j);
    double cij = fState.IntCovariance()(k, l);
    double tmp = std::sqrt(std::abs(fState.IntCovariance()(k, k) * fState.IntCovariance()(l, l)));
    if (tmp > 0)
      return cij / tmp;
    return 0;
  }

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 540 of file HybridMinimizer.cc.

References fDim, fState, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, and MainPageGenerator::l.

                                                                        {
    // get value of covariance matrices (transform from external to internal indices)
    if (i >= fDim || i >= fDim)
      return 0;
    if (!fState.HasCovariance())
      return 0;  // no info available when minimization has failed
    if (fState.Parameter(i).IsFixed() || fState.Parameter(i).IsConst())
      return 0;
    if (fState.Parameter(j).IsFixed() || fState.Parameter(j).IsConst())
      return 0;
    unsigned int k = fState.IntOfExt(i);
    unsigned int l = fState.IntOfExt(j);
    return fState.Covariance()(k, l);
  }

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 973 of file HybridMinimizer.cc.

References fMinimum, and fState.

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

    if (fMinimum) {
      // 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;
  }

Edm()

double PSFitter::HybridMinimizer::Edm ( ) const

inlineoverride

return expected distance reached from the minimum

Definition at line 134 of file HybridMinimizer.h.

References fState.

{ return fState.Edm(); }

Errors()

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

override

return errors at the minimum

Definition at line 519 of file HybridMinimizer.cc.

References cms::cuda::assert(), fDim, fErrors, fState, and mps_fire::i.

                                              {
    // return error at minimum (set to zero for fixed and constant params)
    const std::vector<MinuitParameter> &paramsObj = fState.MinuitParameters();
    if (paramsObj.empty())
      return nullptr;
    assert(fDim == paramsObj.size());
    // be careful for multiple calls of this function. I will redo an allocation here
    // only when size of vectors has changed (e.g. after a new minimization)
    if (fErrors.size() != fDim)
      fErrors.resize(fDim);
    for (unsigned int i = 0; i < fDim; ++i) {
      const MinuitParameter &par = paramsObj[i];
      if (par.IsFixed() || par.IsConst())
        fErrors[i] = 0;
      else
        fErrors[i] = par.Error();
    }

    return &fErrors.front();
  }

ExamineMinimum()

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

protected

examine the minimum result

study the function minimum

Definition at line 404 of file HybridMinimizer.cc.

References HLT_2022v12_cff::debugLevel, SiStripPI::min, PrintResults(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by Minimize().

                                                                            {

    // debug ( print all the states)
    int debugLevel = PrintLevel();
    if (debugLevel >= 3) {
      /*      
      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)
        edm::LogInfo("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;
      }
      edm::LogInfo("HybridMinimizer::Minimize").format("Minimization did NOT converge, {}", txt);
    }

    if (debugLevel >= 1)
      PrintResults();
    return validMinimum;
  }

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 555 of file HybridMinimizer.cc.

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

                                                      {
    // get value of covariance matrices
    if (!fState.HasCovariance())
      return false;  // no info available when minimization has failed
    for (unsigned int i = 0; i < fDim; ++i) {
      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;
  }

GetFCN()

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

inlineprotectedvirtual

Definition at line 267 of file HybridMinimizer.h.

References fMinuitFCN.

Referenced by Minimize().

{ return 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 583 of file HybridMinimizer.cc.

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

                                                           {
    // get value of Hessian matrix
    // this is the second derivative matrices
    if (!fState.HasCovariance())
      return false;  // no info available when minimization has failed
    for (unsigned int i = 0; i < fDim; ++i) {
      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;
  }

GetMinimizer()

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

inlineprotectedvirtual

Definition at line 263 of file HybridMinimizer.h.

References fMinimizer.

Referenced by Minimize().

{ return 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 648 of file HybridMinimizer.cc.

References cms::cuda::assert(), HLT_2022v12_cff::debugLevel, fMinimum, fMinuitFCN, fState, mps_fire::i, sistrip::SpyUtilities::isValid(), LaserClient_cfi::low, SiStripPI::max, hlt_dqm_clientPB-live_cfg::me, PSFitter::RestoreGlobalPrintLevel(), g4SimHits_cfi::Tolerance, PSFitter::TurnOffPrintInfoLevel(), and up.

                                                                                               {
    // return the minos error for parameter i
    // if a minimum does not exist an error is returned
    // runopt is a flag which specifies if only lower or upper error needs to be run
    // if runopt = 0 both, = 1 only lower, + 2 only upper errors
    errLow = 0;
    errUp = 0;
    bool runLower = runopt != 2;
    bool runUpper = runopt != 1;

    assert(fMinuitFCN);

    // need to know if parameter is const or fixed
    if (fState.Parameter(i).IsConst() || fState.Parameter(i).IsFixed()) {
      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) {
      edm::LogError("HybridMinimizer::GetMinosErrors") << "  failed - no function minimum existing";
      return false;
    }

    if (!fMinimum->IsValid()) {
      edm::LogError("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;
  }

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 632 of file HybridMinimizer.cc.

References fDim, fState, mps_fire::i, and dqmdumpme::k.

                                                       {
    // get global correlation coefficient for the parameter i. This is a number between zero and one which gives
    // the correlation between the i-th parameter  and that linear combination of all other parameters which
    // is most strongly correlated with i.

    if (i >= fDim || i >= fDim)
      return 0;
    // no info available when minimization has failed or has some problems
    if (!fState.HasGlobalCC())
      return 0;
    if (fState.Parameter(i).IsFixed() || fState.Parameter(i).IsConst())
      return 0;
    unsigned int k = fState.IntOfExt(i);
    return fState.GlobalCC().GlobalCC()[k];
  }

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 905 of file HybridMinimizer.cc.

References fMinimum, fMinuitFCN, fState, PSFitter::RestoreGlobalPrintLevel(), and PSFitter::TurnOffPrintInfoLevel().

                              {
    // find Hessian (full second derivative calculations)
    // the contained state will be updated with the Hessian result
    // in case a function minimum exists and is valid the result will be
    // appended in the function minimum

    if (!fMinuitFCN) {
      edm::LogError("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)
        edm::LogInfo("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;
  }

MinGradient()

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

inlineoverride

return pointer to gradient values at the minimum

Definition at line 140 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 294 of file HybridMinimizer.cc.

References cms::cuda::assert(), ExamineMinimum(), fMinimum, fMinuitFCN, fState, GetFCN(), GetMinimizer(), SiStripPI::min, convertSQLiteXML::ok, PSFitter::RestoreGlobalPrintLevel(), g4SimHits_cfi::Tolerance, and PSFitter::TurnOffPrintInfoLevel().

Referenced by PulseShapeFitOOTPileupCorrection::fit().

                                 {
    // perform the minimization
    // store a copy of FunctionMinimum
    if (!fMinuitFCN) {
      edm::LogError("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()); // MnPrint::SetLevel is not a static method anymore. Using it requires an object to exist

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

MinValue()

double PSFitter::HybridMinimizer::MinValue ( ) const

inlineoverride

return minimum function value

Definition at line 131 of file HybridMinimizer.h.

References fState.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

{ return fState.Fval(); }

NCalls()

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

inlineoverride

number of function calls to reach the minimum

Definition at line 143 of file HybridMinimizer.h.

References fState.

{ 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 147 of file HybridMinimizer.h.

References fDim.

{ 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 151 of file HybridMinimizer.h.

References fState.

{ return fState.VariableParameters(); }

operator=()

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

private

Assignment operator

Definition at line 144 of file HybridMinimizer.cc.

                                                                        {
    // Implementation of assignment operator.
    if (this == &rhs)
      return *this;  // time saving self-test
    return *this;
  }

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 468 of file HybridMinimizer.cc.

References fMinimum.

Referenced by ExamineMinimum().

                                     {
    // print results of minimization
    if (!fMinimum)
      return;
    if (fMinimum->IsValid()) {
      // 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;
*/
    }
  }

ProvidesError()

bool PSFitter::HybridMinimizer::ProvidesError ( ) const

inlineoverride

minimizer provides error and error matrix

Definition at line 154 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 801 of file HybridMinimizer.cc.

References fMinuitFCN, fState, mps_fire::i, PSFitter::RestoreGlobalPrintLevel(), mps_fire::result, jetUpdater_cfi::sort, PSFitter::TurnOffPrintInfoLevel(), x, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

                                                                                                                   {
    // scan a parameter (variable) around the minimum value
    // the parameters must have been set before
    // if xmin=0 && xmax == 0  by default scan around 2 sigma of the error
    // if the errors  are also zero then scan from min and max of parameter range

    if (!fMinuitFCN) {
      edm::LogError("HybridMinimizer::Scan") << " Function must be set before using Scan";
      return false;
    }

    if (ipar > fState.MinuitParameters().size()) {
      edm::LogError("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) {
      edm::LogError("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)
        edm::LogInfo("HybridMinimizer::Scan") << "A new minimum has been found";
      fState.SetValue(ipar, scan.Parameters().Value(ipar));
    }

    return true;
  }

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 215 of file HybridMinimizer.cc.

References funct::abs(), fState, Skims_PA_cff::name, SetVariable(), and heppy_batch::val.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

                                                                                             {
    // add a fixed variable
    // need a step size otherwise treated as a constant
    // use 10%
    double step = (val != 0) ? 0.1 * std::abs(val) : 0.1;
    if (!SetVariable(ivar, name, val, step)) {
      ivar = fState.Index(name);
    }
    fState.Fix(ivar);
    return true;
  }

SetFunction() [1/2]

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

override

set the function to minimize

Definition at line 258 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, EcalMonitorTask_cff::func, and fUseFumili.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

                                                                         {
    // set function to be minimized
    if (fMinuitFCN)
      delete fMinuitFCN;
    fDim = func.NDim();
    if (!fUseFumili) {
      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) {
        edm::LogError("HybridMinimizer::SetFunction") << "HybridMinimizer: Wrong Fit method function for Fumili";
        return;
      }
      fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodFunction>(*fcnfunc, fDim, ErrorDef());
    }
  }

SetFunction() [2/2]

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

override

set gradient the function to minimize

Definition at line 276 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, EcalMonitorTask_cff::func, and fUseFumili.

                                                                          {
    // set function to be minimized
    fDim = func.NDim();
    if (fMinuitFCN)
      delete fMinuitFCN;
    if (!fUseFumili) {
      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) {
        edm::LogError("HybridMinimizer::SetFunction") << "HybridMinimizer: Wrong Fit method function for Fumili";
        return;
      }
      fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodGradFunction>(*fcnfunc, fDim, ErrorDef());
    }
  }

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 206 of file HybridMinimizer.cc.

References fState, Skims_PA_cff::name, SetVariable(), and heppy_batch::val.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

                                                                                                     {
    // add a double bound variable
    if (!SetVariable(ivar, name, val, step))
      return false;
    fState.SetLimits(ivar, lower, upper);
    return true;
  }

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 188 of file HybridMinimizer.cc.

References fState, Skims_PA_cff::name, SetVariable(), and heppy_batch::val.

                                                                                       {
    // add a lower bounded variable
    if (!SetVariable(ivar, name, val, step))
      return false;
    fState.SetLowerLimit(ivar, lower);
    return true;
  }

SetMinimizer()

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

inlineprotectedvirtual

Definition at line 265 of file HybridMinimizer.h.

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

Referenced by SetMinimizerType().

{ fMinimizer = m; }

SetMinimizerType()

void PSFitter::HybridMinimizer::SetMinimizerType

(

EMinimizerType

type

)

Definition at line 98 of file HybridMinimizer.cc.

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

Referenced by PulseShapeFitOOTPileupCorrection::fit(), and HybridMinimizer().

                                                            {
    // Set  minimizer algorithm type
    fUseFumili = false;

    if (fMinimizer)
      delete fMinimizer;

    switch (type) {
      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());
    }
  }

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 197 of file HybridMinimizer.cc.

References fState, Skims_PA_cff::name, SetVariable(), and heppy_batch::val.

                                                                                       {
    // add a upper bounded variable
    if (!SetVariable(ivar, name, val, step))
      return false;
    fState.SetUpperLimit(ivar, upper);
    return true;
  }

SetVariable()

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

override

set free variable

Definition at line 162 of file HybridMinimizer.cc.

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

Referenced by SetFixedVariable(), SetLimitedVariable(), SetLowerLimitedVariable(), and SetUpperLimitedVariable().

                                                                                                     {
    // set a free variable.
    // Add the variable if not existing otherwise  set value if exists already
    // this is implemented in MnUserParameterState::Add
    // if index is wrong (i.e. variable already exists but with a different index return false) but
    // value is set for corresponding variable name

    //    std::cout << " add parameter " << name << "  " <<  val << " step " << step << std::endl;

    if (step <= 0) {
      edm::LogInfo("HybridMinimizer::SetVariable")
          .format("Parameter {} has zero or invalid step size - consider it as constant", name);
      fState.Add(name, val);
    } else
      fState.Add(name, val, step);

    unsigned int minuit2Index = fState.Index(name);
    if (minuit2Index != ivar) {
      edm::LogInfo("HybridMinimizer::SetVariable").format("Wrong index used for the variable {} {}", name, minuit2Index);
      return false;
    }
    fState.RemoveLimits(ivar);

    return true;
  }

SetVariableValue()

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

override

set variable

Definition at line 240 of file HybridMinimizer.cc.

References fState, and heppy_batch::val.

                                                                      {
    // set value for variable ivar (only for existing parameters)
    if (ivar >= fState.MinuitParameters().size())
      return false;
    fState.SetValue(ivar, val);
    return true;
  }

SetVariableValues()

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

override

Definition at line 248 of file HybridMinimizer.cc.

References fState, dqmiodumpmetadata::n, and x.

                                                         {
    // set value for variable ivar (only for existing parameters)
    unsigned int n = fState.MinuitParameters().size();
    if (n == 0)
      return false;
    for (unsigned int ivar = 0; ivar < n; ++ivar)
      fState.SetValue(ivar, x[ivar]);
    return true;
  }

State()

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

inline

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

Definition at line 256 of file HybridMinimizer.h.

References fState.

{ return fState; }

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 234 of file HybridMinimizer.cc.

References fState, and Skims_PA_cff::name.

                                                                {
    // return the variable index
    // check if variable exist
    return fState.Trafo().FindIndex(name);
  }

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 227 of file HybridMinimizer.cc.

References fState, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 {
    // return the variable name
    if (ivar >= fState.MinuitParameters().size())
      return std::string();
    return fState.GetName(ivar);
  }

X()

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

override

return pointer to X values at the minimum

Definition at line 502 of file HybridMinimizer.cc.

References cms::cuda::assert(), fDim, fState, fValues, and mps_fire::i.

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

                                         {
    // return values at minimum
    const std::vector<MinuitParameter> &paramsObj = fState.MinuitParameters();
    if (paramsObj.empty())
      return nullptr;
    assert(fDim == paramsObj.size());
    // be careful for multiple calls of this function. I will redo an allocation here
    // only when size of vectors has changed (e.g. after a new minimization)
    if (fValues.size() != fDim)
      fValues.resize(fDim);
    for (unsigned int i = 0; i < fDim; ++i) {
      fValues[i] = paramsObj[i].Value();
    }

    return &fValues.front();
  }

Member Data Documentation

fDim

unsigned int PSFitter::HybridMinimizer::fDim

private

Definition at line 273 of file HybridMinimizer.h.

Referenced by Correlation(), CovMatrix(), Errors(), GetCovMatrix(), GetHessianMatrix(), GlobalCC(), NDim(), SetFunction(), and X().

fErrors

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

mutableprivate

Definition at line 282 of file HybridMinimizer.h.

Referenced by Errors().

fMinimizer

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

private

Definition at line 278 of file HybridMinimizer.h.

Referenced by GetMinimizer(), SetMinimizer(), SetMinimizerType(), and ~HybridMinimizer().

fMinimum

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

private

Definition at line 280 of file HybridMinimizer.h.

Referenced by Clear(), Contour(), CovMatrixStatus(), GetMinosError(), Hesse(), Minimize(), PrintResults(), and ~HybridMinimizer().

fMinuitFCN

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

private

Definition at line 279 of file HybridMinimizer.h.

Referenced by Contour(), GetFCN(), GetMinosError(), Hesse(), Minimize(), Scan(), SetFunction(), and ~HybridMinimizer().

fState

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

private

Definition at line 276 of file HybridMinimizer.h.

Referenced by Clear(), Contour(), Correlation(), CovMatrix(), CovMatrixStatus(), Edm(), Errors(), GetCovMatrix(), GetHessianMatrix(), GetMinosError(), GlobalCC(), Hesse(), Minimize(), MinValue(), NCalls(), NFree(), Scan(), SetFixedVariable(), SetLimitedVariable(), SetLowerLimitedVariable(), SetUpperLimitedVariable(), SetVariable(), SetVariableValue(), SetVariableValues(), State(), VariableIndex(), VariableName(), and X().

fUseFumili

bool PSFitter::HybridMinimizer::fUseFumili

private

Definition at line 274 of file HybridMinimizer.h.

Referenced by SetFunction(), and SetMinimizerType().

fValues

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

mutableprivate

Definition at line 281 of file HybridMinimizer.h.

Referenced by X().