#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

enum PSFitter::HybridMinimizer::EMinimizerType

Enumerator
kMigrad
kSimplex
kCombined
kScan
kFumili

Definition at line 49 of file HybridMinimizer.h.

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

Constructor & Destructor Documentation

PSFitter::HybridMinimizer::HybridMinimizer ( EMinimizerType type = kMigrad )

Default constructor

Definition at line 73 of file HybridMinimizer.cc.

References SetMinimizerType().

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

PSFitter::HybridMinimizer::HybridMinimizer ( const char * type )

Constructor with a char (used by PM)

Definition at line 84 of file HybridMinimizer.cc.

References estimatePileup2::algoname, particleFlow_cfi::algoType, createfilelist::int, kCombined, kFumili, kMigrad, kScan, kSimplex, SetMinimizerType(), AlCaHLTBitMon_QueryRunRegistry::string, and create_public_lumi_plots::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);
 }

PSFitter::HybridMinimizer::~HybridMinimizer ( )

override

Destructor (no operations)

Definition at line 138 of file HybridMinimizer.cc.

References fMinimizer, fMinimum, and fMinuitFCN.

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

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

private

Copy constructor

Definition at line 146 of file HybridMinimizer.cc.

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

Member Function Documentation

void PSFitter::HybridMinimizer::Clear ( )

override

Definition at line 160 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;
 }

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

References fMinimum, fMinuitFCN, fState, mps_fire::i, npoints, PSFitter::RestoreGlobalPrintLevel(), mps_fire::result, and PSFitter::TurnOffPrintInfoLevel().

                                                                                                                   {
    // contour plot for parameter i and j
    // need a valid FunctionMinimum otherwise exits
    if (fMinimum == nullptr) { 
       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;
    
 
 }

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

References funct::abs(), fDim, fState, gen::k, checklumidiff::l, mathSSE::sqrt(), and 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; 
 }

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

References fDim, fState, gen::k, and checklumidiff::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); 
 }

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

double PSFitter::HybridMinimizer::Edm ( ) const

inlineoverride

return expected distance reached from the minimum

Definition at line 136 of file HybridMinimizer.h.

References hcaldqm::quantity::fState, and X.

136 { return fState.Edm(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

override

return errors at the minimum

Definition at line 528 of file HybridMinimizer.cc.

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

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

protected

examine the minimum result

study the function minimum

Definition at line 412 of file HybridMinimizer.cc.

References UEAnalysisJets_cfi::debugLevel, mps_check::msg, 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)  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;
 }

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

References fDim, fState, mps_fire::i, gen::k, checklumidiff::l, and funct::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;
 }

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

inlineprotectedvirtual

Definition at line 274 of file HybridMinimizer.h.

References min().

Referenced by Minimize().

274 { return fMinuitFCN; }

PSFitter::HybridMinimizer::fMinuitFCN

ROOT::Minuit2::FCNBase * fMinuitFCN

Definition: HybridMinimizer.h:287

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

References fDim, fState, mps_fire::i, gen::k, checklumidiff::l, and funct::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;
 }

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

inlineprotectedvirtual

Definition at line 270 of file HybridMinimizer.h.

Referenced by Minimize().

270 { return fMinimizer; }

PSFitter::HybridMinimizer::fMinimizer

ROOT::Minuit2::ModularFunctionMinimizer * fMinimizer

Definition: HybridMinimizer.h:286

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

References UEAnalysisJets_cfi::debugLevel, fMinimum, fMinuitFCN, fState, SiStripPI::max, 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) { 
       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;  
 } 

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

References fDim, fState, and gen::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]; 
 }

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 895 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) { 
       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;       
 }

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

inlineoverride

return pointer to gradient values at the minimum

Definition at line 142 of file HybridMinimizer.h.

142 { return nullptr; } // not available in Minuit2

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

References ExamineMinimum(), fMinimum, fMinuitFCN, fState, GetFCN(), GetMinimizer(), 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) { 
       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; 
 }

double PSFitter::HybridMinimizer::MinValue ( ) const

inlineoverride

return minimum function value

Definition at line 133 of file HybridMinimizer.h.

References hcaldqm::quantity::fState.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

133 { return fState.Fval(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

inlineoverride

number of function calls to reach the minimum

Definition at line 145 of file HybridMinimizer.h.

References hcaldqm::quantity::fState.

145 { return fState.NFcn(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

inlineoverride

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

Definition at line 149 of file HybridMinimizer.h.

149 { return fDim; }

PSFitter::HybridMinimizer::fDim

unsigned int fDim

Definition: HybridMinimizer.h:281

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

References hcaldqm::quantity::fState.

153 { return fState.VariableParameters(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

private

Assignment operator

Definition at line 152 of file HybridMinimizer.cc.

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

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

bool PSFitter::HybridMinimizer::ProvidesError ( ) const

inlineoverride

minimizer provides error and error matrix

Definition at line 156 of file HybridMinimizer.h.

References h, mps_fire::i, npoints, protons_cff::xi, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

156 { return true; }

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

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

                                                                                                                     { 
    // 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) { 
       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 PSFitter::HybridMinimizer::SetFixedVariable	(	unsigned int	ivar,
		const std::string &	name,
		double	val
	)

override

set fixed variable (override if minimizer supports them )

Definition at line 223 of file HybridMinimizer.cc.

References funct::abs(), fState, and SetVariable().

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

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

override

set the function to minimize

Definition at line 266 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, patCandidates_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) {
          MN_ERROR_MSG("HybridMinimizer: Wrong Fit method function for Fumili");
          return;
       }
       fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodFunction> (*fcnfunc, fDim, ErrorDef() );
    }
 }

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

override

set gradient the function to minimize

Definition at line 284 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, patCandidates_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) {
          MN_ERROR_MSG("HybridMinimizer: Wrong Fit method function for Fumili");
          return;
       }
       fMinuitFCN = new ROOT::Minuit2::FumiliFCNAdapter<ROOT::Math::FitMethodGradFunction> (*fcnfunc, fDim, ErrorDef() );
    }
 }

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

References fState, and SetVariable().

Referenced by PulseShapeFitOOTPileupCorrection::fit().

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

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

References fState, and SetVariable().

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

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

inlineprotectedvirtual

Definition at line 272 of file HybridMinimizer.h.

References funct::m.

Referenced by SetMinimizerType().

272 { fMinimizer = m; }

funct::m

m

Definition: Factorize.h:56

PSFitter::HybridMinimizer::fMinimizer

ROOT::Minuit2::ModularFunctionMinimizer * fMinimizer

Definition: HybridMinimizer.h:286

void PSFitter::HybridMinimizer::SetMinimizerType ( EMinimizerType type )

Definition at line 106 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() );
    }
 }

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

References fState, and SetVariable().

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

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

override

set free variable

Definition at line 171 of file HybridMinimizer.cc.

References fState, and AlCaHLTBitMon_QueryRunRegistry::string.

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) { 
       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 PSFitter::HybridMinimizer::SetVariableValue	(	unsigned int	ivar,
		double	val
	)

override

set variable

Definition at line 249 of file HybridMinimizer.cc.

References fState.

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

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

override

Definition at line 256 of file HybridMinimizer.cc.

References fState, and gen::n.

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

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

inline

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

Definition at line 262 of file HybridMinimizer.h.

References hcaldqm::quantity::fState.

262 { return fState; }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

References fState.

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

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

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

override

return pointer to X values at the minimum

Definition at line 512 of file HybridMinimizer.cc.

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