PSFitter::HybridMinimizer Class Reference

#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 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(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 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 == 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, 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

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, 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

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 hcaldqm::quantity::fState, and X.

{ return fState.Edm(); }

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

virtual

return errors at the minimum

Definition at line 527 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.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 UEAnalysisJets_cfi::debugLevel, mps_alisetup::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, 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().

{ return fMinuitFCN; } 

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

{ return fMinimizer; } 

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 UEAnalysisJets_cfi::debugLevel, fMinimum, fMinuitFCN, fState, hpstanc_transforms::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 == 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 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 ( )

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.

{ 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 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() != 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 hcaldqm::quantity::fState.

Referenced by PulseShapeFitOOTPileupCorrection::fit().

{ return fState.Fval(); } 

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 hcaldqm::quantity::fState.

{ return fState.NFcn(); } 

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.

{ return fDim; }   

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 hcaldqm::quantity::fState.

{ return fState.VariableParameters(); }  

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.

References mps_fire::i, npoints, x(), hybridSuperClusters_cfi::xi, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

{ 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, mps_fire::i, PSFitter::RestoreGlobalPrintLevel(), mps_fire::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, 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.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, RecoEcal_EventContent_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 )

virtual

set gradient the function to minimize

Definition at line 285 of file HybridMinimizer.cc.

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

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 funct::m.

Referenced by SetMinimizerType().

{ fMinimizer = m; } 

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, AlCaHLTBitMon_QueryRunRegistry::string, and heppy_batch::val.

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

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

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

   if (step <= 0) { 
      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 hcaldqm::quantity::fState.

{ return fState; }

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

Member Data Documentation

unsigned int PSFitter::HybridMinimizer::fDim

private

Definition at line 281 of file HybridMinimizer.h.

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

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

mutableprivate

Definition at line 290 of file HybridMinimizer.h.

Referenced by Errors().

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

private

Definition at line 286 of file HybridMinimizer.h.

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

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

private

Definition at line 288 of file HybridMinimizer.h.

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

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

private

Definition at line 287 of file HybridMinimizer.h.

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

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

private

Definition at line 284 of file HybridMinimizer.h.

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

bool PSFitter::HybridMinimizer::fUseFumili

private

Definition at line 282 of file HybridMinimizer.h.

Referenced by SetFunction(), and SetMinimizerType().

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

mutableprivate

Definition at line 289 of file HybridMinimizer.h.

Referenced by X().