#include <HybridMinimizer.h>

Inheritance diagram for PSFitter::HybridMinimizer:

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

Public Member Functions
virtual void	Clear ()

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

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

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

virtual int	CovMatrixStatus () const

virtual double	Edm () const
	return expected distance reached from the minimum More...

virtual const double *	Errors () const
	return errors at the minimum More...

virtual bool	GetCovMatrix (double *cov) const

virtual bool	GetHessianMatrix (double *h) const

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

virtual double	GlobalCC (unsigned int i) const

virtual bool	Hesse ()

	HybridMinimizer (EMinimizerType type=kMigrad)

	HybridMinimizer (const char *type)

virtual const double *	MinGradient () const
	return pointer to gradient values at the minimum More...

virtual bool	Minimize ()

virtual double	MinValue () const
	return minimum function value More...

virtual unsigned int	NCalls () const
	number of function calls to reach the minimum More...

virtual unsigned int	NDim () const

virtual unsigned int	NFree () const

virtual void	PrintResults ()
	print result of minimization More...

virtual bool	ProvidesError () const
	minimizer provides error and error matrix More...

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

virtual bool	SetFixedVariable (unsigned int, const std::string &, double)
	set fixed variable (override if minimizer supports them ) More...

virtual void	SetFunction (const ROOT::Math::IMultiGenFunction &func)
	set the function to minimize More...

virtual void	SetFunction (const ROOT::Math::IMultiGradFunction &func)
	set gradient the function to minimize More...

virtual bool	SetLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double, double)
	set upper/lower limited variable (override if minimizer supports them ) More...

virtual bool	SetLowerLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double lower)
	set lower limit variable (override if minimizer supports them ) More...

void	SetMinimizerType (EMinimizerType type)

virtual bool	SetUpperLimitedVariable (unsigned int ivar, const std::string &name, double val, double step, double upper)
	set upper limit variable (override if minimizer supports them ) More...

virtual bool	SetVariable (unsigned int ivar, const std::string &name, double val, double step)
	set free variable More...

virtual bool	SetVariableValue (unsigned int ivar, double val)
	set variable More...

virtual bool	SetVariableValues (const double *val)

const ROOT::Minuit2::MnUserParameterState &	State ()
	return the minimizer state (containing values, step size , etc..) More...

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

virtual std::string	VariableName (unsigned int ivar) const
	get name of variables (override if minimizer support storing of variable names) More...

virtual const double *	X () const
	return pointer to X values at the minimum More...

virtual	~HybridMinimizer ()

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(0),
    fMinuitFCN(0),
    fMinimum(0)   
 {
    // 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 HLT_FULL_cff::algoType, kCombined, kFumili, kMigrad, kScan, kSimplex, SetMinimizerType(), AlCaHLTBitMon_QueryRunRegistry::string, and create_public_lumi_plots::transform.

                                                     : 
    Minimizer(),
    fDim(0),
    fMinimizer(0),
    fMinuitFCN(0),
    fMinimum(0)   
 {   
    // 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 ( )

virtual

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

virtual

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

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

virtual

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

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

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

virtual

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

Definition at line 614 of file HybridMinimizer.cc.

References funct::abs(), fDim, fState, relval_2017::k, cmsLHEtoEOSManager::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

virtual

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

References fDim, fState, relval_2017::k, and cmsLHEtoEOSManager::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

virtual

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

virtual double PSFitter::HybridMinimizer::Edm ( ) const

inlinevirtual

return expected distance reached from the minimum

Definition at line 136 of file HybridMinimizer.h.

References fState.

136 { return fState.Edm(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

virtual

return errors at the minimum

Definition at line 527 of file HybridMinimizer.cc.

References assert(), fDim, fErrors, fState, and i.

                                              { 
    // return error at minimum (set to zero for fixed and constant params)
    const std::vector<MinuitParameter> & paramsObj = fState.MinuitParameters();
    if (paramsObj.size() == 0) return 0;
    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 411 of file HybridMinimizer.cc.

References HLT_FULL_cff::debugLevel, visualization-live-secondInstance_cfg::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

virtual

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

References fDim, fState, i, j, relval_2017::k, cmsLHEtoEOSManager::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;
 }

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

inlineprotectedvirtual

Definition at line 274 of file HybridMinimizer.h.

References fMinuitFCN.

Referenced by Minimize().

274 { return fMinuitFCN; }

PSFitter::HybridMinimizer::fMinuitFCN

ROOT::Minuit2::FCNBase * fMinuitFCN

Definition: HybridMinimizer.h:287

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

virtual

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

References fDim, fState, i, j, relval_2017::k, cmsLHEtoEOSManager::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;
 }

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

inlineprotectedvirtual

Definition at line 270 of file HybridMinimizer.h.

References fMinimizer.

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

virtual

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

References assert(), HLT_FULL_cff::debugLevel, fMinimum, fMinuitFCN, fState, bookConverter::max, PSFitter::RestoreGlobalPrintLevel(), g4TestOverlap_cfg::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 == 0) { 
       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

virtual

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

References fDim, fState, and relval_2017::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 ( )

virtual

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

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

inlinevirtual

return pointer to gradient values at the minimum

Definition at line 142 of file HybridMinimizer.h.

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

bool PSFitter::HybridMinimizer::Minimize ( )

virtual

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

References assert(), ExamineMinimum(), fMinimum, fMinuitFCN, fState, GetFCN(), GetMinimizer(), min(), convertSQLiteXML::ok, PSFitter::RestoreGlobalPrintLevel(), g4TestOverlap_cfg::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() != 0 );
 
    // delete result of previous minimization
    if (fMinimum) delete fMinimum; 
    fMinimum = 0;
 
 
    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 != 0) {
       // 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; 
 }

virtual double PSFitter::HybridMinimizer::MinValue ( ) const

inlinevirtual

return minimum function value

Definition at line 133 of file HybridMinimizer.h.

References fState.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

133 { return fState.Fval(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

inlinevirtual

number of function calls to reach the minimum

Definition at line 145 of file HybridMinimizer.h.

References fState.

145 { return fState.NFcn(); }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

inlinevirtual

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

Definition at line 149 of file HybridMinimizer.h.

References fDim.

149 { return fDim; }

PSFitter::HybridMinimizer::fDim

unsigned int fDim

Definition: HybridMinimizer.h:281

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

inlinevirtual

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

virtual

print result of minimization

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

Definition at line 477 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;
 */
    }
 }

virtual bool PSFitter::HybridMinimizer::ProvidesError ( ) const

inlinevirtual

minimizer provides error and error matrix

Definition at line 156 of file HybridMinimizer.h.

156 { return true; }

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

virtual

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

References fMinuitFCN, fState, i, PSFitter::RestoreGlobalPrintLevel(), query::result, 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
	)

virtual

set fixed variable (override if minimizer supports them )

Definition at line 224 of file HybridMinimizer.cc.

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

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.c_str() );      
    }
    fState.Fix(ivar);
    return true;
 }

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

virtual

set the function to minimize

Definition at line 267 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, 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 )

virtual

set gradient the function to minimize

Definition at line 285 of file HybridMinimizer.cc.

References fDim, fMinuitFCN, 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
	)

virtual

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

Definition at line 217 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
	)

virtual

set lower limit variable (override if minimizer supports them )

Definition at line 201 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 fMinimizer, and visualization-live-secondInstance_cfg::m.

Referenced by SetMinimizerType().

272 { fMinimizer = m; }

visualization-live-secondInstance_cfg.m

tuple m

Definition: visualization-live-secondInstance_cfg.py:45

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
	)

virtual

set upper limit variable (override if minimizer supports them )

Definition at line 208 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
	)

virtual

set free variable

Definition at line 171 of file HybridMinimizer.cc.

References fState, relval_parameters_module::step, 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.c_str(), val);
    }
    else 
       fState.Add(name.c_str(), val, step); 
 
    unsigned int minuit2Index = fState.Index(name.c_str() ); 
    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);  
       ivar = minuit2Index;
       return false;
    }
    fState.RemoveLimits(ivar);
 
    return true; 
 }

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

virtual

set variable

Definition at line 250 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 )

virtual

Definition at line 257 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 fState.

262 { return fState; }

PSFitter::HybridMinimizer::fState

ROOT::Minuit2::MnUserParameterState fState

Definition: HybridMinimizer.h:284

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

virtual

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

Definition at line 243 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

virtual

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

Definition at line 236 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

virtual

return pointer to X values at the minimum

Definition at line 511 of file HybridMinimizer.cc.

References assert(), fDim, fState, fValues, and i.

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

                                         { 
    // return values at minimum 
    const std::vector<MinuitParameter> & paramsObj = fState.MinuitParameters();
    if (paramsObj.size() == 0) return 0;
    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(); 
 }