Minuit2Minimizer Class Reference

Inheritance diagram for Minuit2Minimizer:

Collaboration diagram for Minuit2Minimizer:

Public Types
typedef ROOT::Math::Minimizer	root_minimizer_t

Public Member Functions
	Minuit2Minimizer (const std::string &algorithmName="Migrad")
	~Minuit2Minimizer ()
void	setStrategy (int value)
int	strategy () const
void	setErrorDefinition (double value)
double	errorDefinition () const
void	setTolerance (double value)
double	tolerance () const
void	setPrecision (double value)
double	precision () const
void	setPrintLevel (int value)
int	printLevel () const
void	setMaxFunctionCalls (int value)
int	maxFunctionCalls () const
std::string	statusToString () const override
std::map< std::string, std::string >	statusMap () const override
bool	requiresResiduals () override
Fit::MinimizerResult	minimize_scalar (fcn_scalar_t fcn, Fit::Parameters parameters) override
Fit::MinimizerResult	minimize_residual (fcn_residual_t fcn, Fit::Parameters parameters) override
std::string	minimizerName () const override final
std::string	algorithmName () const override final
void	setParameters (const Fit::Parameters &parameters)
double	minValue () const override final
MinimizerOptions &	options ()
const MinimizerOptions &	options () const
bool	providesError () const
void	setOptions (const std::string &optionString) override final
virtual void	clear ()

Protected Member Functions
void	propagateOptions () override
const root_minimizer_t *	rootMinimizer () const override
Fit::MinimizerResult	minimize (Fit::Parameters parameters)
void	propagateResults (Fit::Parameters &parameters)
virtual void	setParameter (unsigned int index, const Fit::Parameter &par)
size_t	fitDimension () const
std::vector< double >	parValuesAtMinimum () const
std::vector< double >	parErrorsAtMinimum () const
root_minimizer_t *	rootMinimizer ()
template<class T >
OptionContainer::option_t	addOption (const std::string &optionName, T value, const std::string &description="")
template<class T >
void	setOptionValue (const std::string &optionName, T value)
template<class T >
T	optionValue (const std::string &optionName) const

Private Attributes
std::unique_ptr< ROOT::Minuit2::Minuit2Minimizer >	m_minuit2_minimizer
MinimizerOptions	m_options
MinimizerInfo	m_minimizerInfo
std::unique_ptr< Fit::ObjectiveFunctionAdapter >	m_adapter
bool	m_status

Detailed Description

Wrapper for the CERN ROOT facade of the Minuit2 minimizer.

See Minuit2 user manual https://root.cern.ch/root/htmldoc/guides/minuit2/Minuit2.pdf.

Definition at line 33 of file Minuit2Minimizer.h.

Member Typedef Documentation

root_minimizer_t

typedef ROOT::Math::Minimizer RootMinimizerAdapter::root_minimizer_t

inherited

Definition at line 46 of file RootMinimizerAdapter.h.

Constructor & Destructor Documentation

Minuit2Minimizer()

Minuit2Minimizer::Minuit2Minimizer

(

const std::string &

algorithmName = "Migrad"

)

Definition at line 47 of file Minuit2Minimizer.cpp.

    : RootMinimizerAdapter(MinimizerInfo::buildMinuit2Info(algorithmName)),
      m_minuit2_minimizer(new ROOT::Minuit2::Minuit2Minimizer(algorithmName.c_str()))
{
    addOption("Strategy", 1, "Minimization strategy (0-low, 1-medium, 2-high quality)");
    addOption("ErrorDef", 1.0, "Error definition factor for parameter error calculation");
    addOption("Tolerance", 0.01, "Tolerance on the function value at the minimum");
    addOption("Precision", -1.0, "Relative floating point arithmetic precision");
    addOption("PrintLevel", 0, "Minimizer internal print level");
    addOption("MaxFunctionCalls", 0, "Maximum number of function calls");
}

References RootMinimizerAdapter::addOption().

Here is the call graph for this function:

~Minuit2Minimizer()

Minuit2Minimizer::~Minuit2Minimizer ( )

default

Member Function Documentation

setStrategy()

void Minuit2Minimizer::setStrategy

(

int

value

)

Sets minimization strategy (0-low, 1-medium, 2-high minimization quality).

At low quality number of function calls will be economized.

Definition at line 61 of file Minuit2Minimizer.cpp.

{
    setOptionValue("Strategy", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

strategy()

int Minuit2Minimizer::strategy

(

)

const

Definition at line 66 of file Minuit2Minimizer.cpp.

{
    return optionValue<int>("Strategy");
}

Referenced by propagateOptions().

setErrorDefinition()

void Minuit2Minimizer::setErrorDefinition

(

double

value

)

Sets error definition factor for parameter error calculation.

If objective function (OF) is the usual chisquare function and if the user wants the usual one-standard-deviation errors, then the error definition should be 1.0. If OF is a negative-log-likelihood function, then 0.5. If OF is a chisquare, but the user wants two-standard-deviation errors, 4.0.

Definition at line 71 of file Minuit2Minimizer.cpp.

{
    setOptionValue("ErrorDef", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

errorDefinition()

double Minuit2Minimizer::errorDefinition

(

)

const

Definition at line 76 of file Minuit2Minimizer.cpp.

{
    return optionValue<double>("ErrorDef");
}

Referenced by propagateOptions().

setTolerance()

void Minuit2Minimizer::setTolerance

(

double

value

)

Sets tolerance on the function value at the minimum.

Minimization will stop when the estimated vertical distance to the minimum (EDM) is less than 0.001*tolerance*ErrorDef. Here ErrorDef=1.0 for chi squared fit and ErrorDef=0.5 for negative log likelihood fit.

Definition at line 81 of file Minuit2Minimizer.cpp.

{
    setOptionValue("Tolerance", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

tolerance()

double Minuit2Minimizer::tolerance

(

)

const

Definition at line 86 of file Minuit2Minimizer.cpp.

{
    return optionValue<double>("Tolerance");
}

Referenced by propagateOptions().

setPrecision()

void Minuit2Minimizer::setPrecision

(

double

value

)

Sets relative floating point arithmetic precision.

Should be adjusted when the user knows that objectiove function value is not calculated to the nominal machine accuracy. Typical values are between 10^-5 and 10^-14.

Definition at line 91 of file Minuit2Minimizer.cpp.

{
    setOptionValue("Precision", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

precision()

double Minuit2Minimizer::precision

(

)

const

Definition at line 96 of file Minuit2Minimizer.cpp.

{
    return optionValue<double>("Precision");
}

Referenced by propagateOptions().

setPrintLevel()

void Minuit2Minimizer::setPrintLevel

(

int

value

)

Sets minimizer internal print level.

Default value is 0 (silent).

Definition at line 101 of file Minuit2Minimizer.cpp.

{
    setOptionValue("PrintLevel", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

printLevel()

int Minuit2Minimizer::printLevel

(

)

const

Definition at line 106 of file Minuit2Minimizer.cpp.

{
    return optionValue<int>("PrintLevel");
}

Referenced by propagateOptions().

setMaxFunctionCalls()

void Minuit2Minimizer::setMaxFunctionCalls

(

int

value

)

Sets maximum number of objective function calls.

Definition at line 111 of file Minuit2Minimizer.cpp.

{
    setOptionValue("MaxFunctionCalls", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

maxFunctionCalls()

int Minuit2Minimizer::maxFunctionCalls

(

)

const

Definition at line 116 of file Minuit2Minimizer.cpp.

{
    return optionValue<int>("MaxFunctionCalls");
}

Referenced by propagateOptions().

statusToString()

std::string Minuit2Minimizer::statusToString ( ) const

overridevirtual

Returns string representation of current minimizer status.

Reimplemented from RootMinimizerAdapter.

Definition at line 121 of file Minuit2Minimizer.cpp.

{
    return statusDescription()[rootMinimizer()->Status()];
}

References rootMinimizer(), and anonymous_namespace{Minuit2Minimizer.cpp}::statusDescription().

Here is the call graph for this function:

statusMap()

std::map< std::string, std::string > Minuit2Minimizer::statusMap ( ) const

overridevirtual

Returns map of string representing different minimizer statuses.

Reimplemented from RootMinimizerAdapter.

Definition at line 126 of file Minuit2Minimizer.cpp.

{
    auto result = RootMinimizerAdapter::statusMap();
    result["Edm"] = StringUtils::scientific(rootMinimizer()->Edm());
    result["CovMatrixStatus"] = covmatrixStatusDescription()[rootMinimizer()->CovMatrixStatus()];
    result["functionCalls"] = std::to_string(rootMinimizer()->NCalls());
    return result;
}

References anonymous_namespace{Minuit2Minimizer.cpp}::covmatrixStatusDescription(), rootMinimizer(), StringUtils::scientific(), and RootMinimizerAdapter::statusMap().

Here is the call graph for this function:

requiresResiduals()

bool Minuit2Minimizer::requiresResiduals ( )

overridevirtual

Returns true if minimizer computations are residual-based, false otherwise.

Reimplemented from IMinimizer.

Definition at line 138 of file Minuit2Minimizer.cpp.

{
    return algorithmName() == "Fumili";
}

References RootMinimizerAdapter::algorithmName().

Here is the call graph for this function:

propagateOptions()

void Minuit2Minimizer::propagateOptions ( )

overrideprotectedvirtual

Propagate options down to ROOT's Minuit2Minimizer.

Implements RootMinimizerAdapter.

Definition at line 145 of file Minuit2Minimizer.cpp.

{
    m_minuit2_minimizer->SetStrategy(strategy());
    m_minuit2_minimizer->SetErrorDef(errorDefinition());
    m_minuit2_minimizer->SetTolerance(tolerance());
    m_minuit2_minimizer->SetPrecision(precision());
    m_minuit2_minimizer->SetPrintLevel(printLevel());
    m_minuit2_minimizer->SetMaxFunctionCalls(static_cast<unsigned int>(maxFunctionCalls()));
}

References errorDefinition(), m_minuit2_minimizer, maxFunctionCalls(), precision(), printLevel(), strategy(), and tolerance().

Here is the call graph for this function:

rootMinimizer() [1/2]

const RootMinimizerAdapter::root_minimizer_t * Minuit2Minimizer::rootMinimizer ( ) const

overrideprotectedvirtual

Implements RootMinimizerAdapter.

Definition at line 155 of file Minuit2Minimizer.cpp.

{
    return m_minuit2_minimizer.get();
}

References m_minuit2_minimizer.

Referenced by statusMap(), and statusToString().

minimize_scalar()

MinimizerResult RootMinimizerAdapter::minimize_scalar ( fcn_scalar_t  , Fit::Parameters    )

overridevirtualinherited

run minimization

Reimplemented from IMinimizer.

Definition at line 32 of file RootMinimizerAdapter.cpp.

{
    // Genetic minimizer requires SetFunction before setParameters, others don't care
    rootMinimizer()->SetFunction(*m_adapter->rootObjectiveFunction(fcn, parameters));
    return minimize(parameters);
}

References RootMinimizerAdapter::m_adapter, RootMinimizerAdapter::minimize(), and RootMinimizerAdapter::rootMinimizer().

Here is the call graph for this function:

minimize_residual()

MinimizerResult RootMinimizerAdapter::minimize_residual ( fcn_residual_t  fcn, Fit::Parameters  parameters  )

overridevirtualinherited

Reimplemented from IMinimizer.

Definition at line 39 of file RootMinimizerAdapter.cpp.

{
    // Genetic minimizer requires SetFunction before setParameters, others don't care
    rootMinimizer()->SetFunction(*m_adapter->rootResidualFunction(fcn, parameters));
    return minimize(parameters);
}

References RootMinimizerAdapter::m_adapter, RootMinimizerAdapter::minimize(), and RootMinimizerAdapter::rootMinimizer().

Here is the call graph for this function:

minimizerName()

std::string RootMinimizerAdapter::minimizerName ( ) const

finaloverridevirtualinherited

Returns name of the minimizer.

Implements IMinimizer.

Definition at line 64 of file RootMinimizerAdapter.cpp.

{
    return m_minimizerInfo.name();
}

References RootMinimizerAdapter::m_minimizerInfo, and MinimizerInfo::name().

Referenced by anonymous_namespace{MinimizerResultUtils.cpp}::reportDescription().

Here is the call graph for this function:

algorithmName()

std::string RootMinimizerAdapter::algorithmName ( ) const

finaloverridevirtualinherited

Returns name of the minimization algorithm.

Implements IMinimizer.

Definition at line 69 of file RootMinimizerAdapter.cpp.

{
    return m_minimizerInfo.algorithmName();
}

References MinimizerInfo::algorithmName(), and RootMinimizerAdapter::m_minimizerInfo.

Referenced by anonymous_namespace{MinimizerResultUtils.cpp}::reportDescription(), and requiresResiduals().

Here is the call graph for this function:

setParameters()

void RootMinimizerAdapter::setParameters ( const Fit::Parameters &  parameters )

inherited

Definition at line 74 of file RootMinimizerAdapter.cpp.

{
    unsigned int index(0);
    for (const auto& par : parameters)
        setParameter(index++, par);
}

References RootMinimizerAdapter::setParameter().

Referenced by RootMinimizerAdapter::minimize().

Here is the call graph for this function:

minValue()

double RootMinimizerAdapter::minValue ( ) const

finaloverridevirtualinherited

Returns minimum function value.

Reimplemented from IMinimizer.

Definition at line 81 of file RootMinimizerAdapter.cpp.

{
    return rootMinimizer()->MinValue();
}

References RootMinimizerAdapter::rootMinimizer().

Referenced by RootMinimizerAdapter::minimize(), and RootMinimizerAdapter::statusMap().

Here is the call graph for this function:

options() [1/2]

MinimizerOptions& RootMinimizerAdapter::options ( )

inlineinherited

Definition at line 63 of file RootMinimizerAdapter.h.

{ return m_options; }

References RootMinimizerAdapter::m_options.

Referenced by anonymous_namespace{MinimizerResultUtils.cpp}::reportOption(), and RootMinimizerAdapter::setOptions().

options() [2/2]

const MinimizerOptions& RootMinimizerAdapter::options ( ) const

inlineinherited

Definition at line 64 of file RootMinimizerAdapter.h.

{ return m_options; }

References RootMinimizerAdapter::m_options.

providesError()

bool RootMinimizerAdapter::providesError ( ) const

inherited

Returns true if minimizer provides error and error matrix.

Definition at line 91 of file RootMinimizerAdapter.cpp.

{
    return rootMinimizer()->ProvidesError();
}

References RootMinimizerAdapter::rootMinimizer().

Referenced by RootMinimizerAdapter::propagateResults(), and RootMinimizerAdapter::statusMap().

Here is the call graph for this function:

setOptions()

void RootMinimizerAdapter::setOptions ( const std::string &  optionString )

finaloverridevirtualinherited

Sets option string to the minimizer.

Reimplemented from IMinimizer.

Definition at line 111 of file RootMinimizerAdapter.cpp.

{
    options().setOptionString(optionString);
}

References RootMinimizerAdapter::options(), and MinimizerOptions::setOptionString().

Here is the call graph for this function:

minimize()

MinimizerResult RootMinimizerAdapter::minimize ( Fit::Parameters  parameters )

protectedinherited

Definition at line 46 of file RootMinimizerAdapter.cpp.

{
    setParameters(parameters);
    propagateOptions();
 
    m_status = rootMinimizer()->Minimize();
    propagateResults(parameters);
 
    MinimizerResult result;
    result.setParameters(parameters);
    result.setMinValue(minValue());
    result.setReport(MinimizerResultUtils::reportToString(*this));
    result.setNumberOfCalls(m_adapter->numberOfCalls());
    result.setNumberOfGradientCalls(m_adapter->numberOfGradientCalls());
 
    return result;
}

References RootMinimizerAdapter::m_adapter, RootMinimizerAdapter::m_status, RootMinimizerAdapter::minValue(), RootMinimizerAdapter::propagateOptions(), RootMinimizerAdapter::propagateResults(), MinimizerResultUtils::reportToString(), RootMinimizerAdapter::rootMinimizer(), Fit::MinimizerResult::setMinValue(), Fit::MinimizerResult::setNumberOfCalls(), Fit::MinimizerResult::setNumberOfGradientCalls(), RootMinimizerAdapter::setParameters(), Fit::MinimizerResult::setParameters(), and Fit::MinimizerResult::setReport().

Referenced by RootMinimizerAdapter::minimize_residual(), and RootMinimizerAdapter::minimize_scalar().

Here is the call graph for this function:

propagateResults()

void RootMinimizerAdapter::propagateResults ( Fit::Parameters &  parameters )

protectedinherited

Propagates results of minimization to fit parameter set.

Definition at line 118 of file RootMinimizerAdapter.cpp.

{
    parameters.setValues(parValuesAtMinimum());
    parameters.setErrors(parErrorsAtMinimum());
    // sets correlation matrix
    if (providesError()) {
        Fit::Parameters::corr_matrix_t matrix;
        matrix.resize(fitDimension());
 
        for (size_t i = 0; i < fitDimension(); ++i) {
            matrix[i].resize(fitDimension(), 0.0);
            for (size_t j = 0; j < fitDimension(); ++j)
                matrix[i][j] = rootMinimizer()->Correlation(static_cast<unsigned int>(i),
                                                            static_cast<unsigned int>(j));
        }
        parameters.setCorrelationMatrix(matrix);
    }
}

References RootMinimizerAdapter::fitDimension(), RootMinimizerAdapter::parErrorsAtMinimum(), RootMinimizerAdapter::parValuesAtMinimum(), RootMinimizerAdapter::providesError(), RootMinimizerAdapter::rootMinimizer(), Fit::Parameters::setCorrelationMatrix(), Fit::Parameters::setErrors(), and Fit::Parameters::setValues().

Referenced by RootMinimizerAdapter::minimize().

Here is the call graph for this function:

setParameter()

void RootMinimizerAdapter::setParameter ( unsigned int  index, const Fit::Parameter &  par  )

protectedvirtualinherited

Reimplemented in GSLLevenbergMarquardtMinimizer, and GeneticMinimizer.

Definition at line 137 of file RootMinimizerAdapter.cpp.

{
    bool success;
    if (par.limits().isFixed()) {
        success = rootMinimizer()->SetFixedVariable(index, par.name().c_str(), par.value());
 
    }
 
    else if (par.limits().isLimited()) {
        success = rootMinimizer()->SetLimitedVariable(index, par.name().c_str(), par.value(),
                                                      par.step(), par.limits().lowerLimit(),
                                                      par.limits().upperLimit());
    }
 
    else if (par.limits().isLowerLimited()) {
        success = rootMinimizer()->SetLowerLimitedVariable(index, par.name().c_str(), par.value(),
                                                           par.step(), par.limits().lowerLimit());
    }
 
    else if (par.limits().isUpperLimited()) {
        success = rootMinimizer()->SetUpperLimitedVariable(index, par.name().c_str(), par.value(),
                                                           par.step(), par.limits().upperLimit());
    }
 
    else if (par.limits().isLimitless()) {
        success = rootMinimizer()->SetVariable(index, par.name().c_str(), par.value(), par.step());
    }
 
    else {
        throw std::runtime_error("BasicMinimizer::setParameter() -> Error! Unexpected parameter.");
    }
 
    if (!success) {
        std::ostringstream ostr;
        ostr << "BasicMinimizer::setParameter() -> Error! Can't set minimizer's fit parameter";
        ostr << "Index:" << index << " name '" << par.name() << "'";
        throw std::runtime_error(ostr.str());
    }
}

References AttLimits::isFixed(), AttLimits::isLimited(), AttLimits::isLimitless(), AttLimits::isLowerLimited(), AttLimits::isUpperLimited(), Fit::Parameter::limits(), AttLimits::lowerLimit(), Fit::Parameter::name(), RootMinimizerAdapter::rootMinimizer(), Fit::Parameter::step(), AttLimits::upperLimit(), and Fit::Parameter::value().

Referenced by GeneticMinimizer::setParameter(), GSLLevenbergMarquardtMinimizer::setParameter(), and RootMinimizerAdapter::setParameters().

Here is the call graph for this function:

fitDimension()

size_t RootMinimizerAdapter::fitDimension ( ) const

protectedinherited

Returns number of fit parameters defined (i.e. dimension of the function to be minimized).

Definition at line 179 of file RootMinimizerAdapter.cpp.

{
    return rootMinimizer()->NDim();
}

References RootMinimizerAdapter::rootMinimizer().

Referenced by RootMinimizerAdapter::parErrorsAtMinimum(), RootMinimizerAdapter::parValuesAtMinimum(), and RootMinimizerAdapter::propagateResults().

Here is the call graph for this function:

parValuesAtMinimum()

std::vector< double > RootMinimizerAdapter::parValuesAtMinimum ( ) const

protectedinherited

Returns value of the variables at minimum.

Definition at line 186 of file RootMinimizerAdapter.cpp.

{
    std::vector<double> result;
    result.resize(fitDimension(), 0.0);
    std::copy(rootMinimizer()->X(), rootMinimizer()->X() + fitDimension(), result.begin());
    return result;
}

References RootMinimizerAdapter::fitDimension(), and RootMinimizerAdapter::rootMinimizer().

Referenced by RootMinimizerAdapter::propagateResults().

Here is the call graph for this function:

parErrorsAtMinimum()

std::vector< double > RootMinimizerAdapter::parErrorsAtMinimum ( ) const

protectedinherited

Returns errors of the variables at minimum.

Definition at line 196 of file RootMinimizerAdapter.cpp.

{
    std::vector<double> result;
    result.resize(fitDimension(), 0.0);
    if (rootMinimizer()->Errors() != 0) {
        std::copy(rootMinimizer()->Errors(), rootMinimizer()->Errors() + fitDimension(),
                  result.begin());
    }
    return result;
}

References RootMinimizerAdapter::fitDimension(), and RootMinimizerAdapter::rootMinimizer().

Referenced by RootMinimizerAdapter::propagateResults().

Here is the call graph for this function:

rootMinimizer() [2/2]

RootMinimizerAdapter::root_minimizer_t * RootMinimizerAdapter::rootMinimizer ( )

protectedinherited

Definition at line 207 of file RootMinimizerAdapter.cpp.

{
    return const_cast<root_minimizer_t*>(
        static_cast<const RootMinimizerAdapter*>(this)->rootMinimizer());
}

References RootMinimizerAdapter::rootMinimizer().

Here is the call graph for this function:

addOption()

template<class T >

OptionContainer::option_t RootMinimizerAdapter::addOption ( const std::string &  optionName, T  value, const std::string &  description = ""  )

protectedinherited

Definition at line 110 of file RootMinimizerAdapter.h.

{
    return m_options.addOption(optionName, value, description);
}

References OptionContainer::addOption(), and RootMinimizerAdapter::m_options.

Referenced by GeneticMinimizer::GeneticMinimizer(), GSLLevenbergMarquardtMinimizer::GSLLevenbergMarquardtMinimizer(), GSLMultiMinimizer::GSLMultiMinimizer(), Minuit2Minimizer(), and SimAnMinimizer::SimAnMinimizer().

Here is the call graph for this function:

setOptionValue()

template<class T >

void RootMinimizerAdapter::setOptionValue ( const std::string &  optionName, T  value  )

protectedinherited

Definition at line 116 of file RootMinimizerAdapter.h.

{
    m_options.setOptionValue(optionName, value);
}

References RootMinimizerAdapter::m_options, and OptionContainer::setOptionValue().

Referenced by SimAnMinimizer::setBoltzmannInitialTemp(), SimAnMinimizer::setBoltzmannK(), SimAnMinimizer::setBoltzmannMinTemp(), SimAnMinimizer::setBoltzmannMu(), setErrorDefinition(), SimAnMinimizer::setIterationsAtEachTemp(), setMaxFunctionCalls(), GeneticMinimizer::setMaxIterations(), GSLLevenbergMarquardtMinimizer::setMaxIterations(), GSLMultiMinimizer::setMaxIterations(), SimAnMinimizer::setMaxIterations(), GeneticMinimizer::setPopulationSize(), setPrecision(), GeneticMinimizer::setPrintLevel(), GSLLevenbergMarquardtMinimizer::setPrintLevel(), GSLMultiMinimizer::setPrintLevel(), setPrintLevel(), SimAnMinimizer::setPrintLevel(), GeneticMinimizer::setRandomSeed(), SimAnMinimizer::setStepSize(), setStrategy(), GeneticMinimizer::setTolerance(), GSLLevenbergMarquardtMinimizer::setTolerance(), and setTolerance().

Here is the call graph for this function:

optionValue()

template<class T >

T RootMinimizerAdapter::optionValue ( const std::string &  optionName ) const

protectedinherited

Definition at line 121 of file RootMinimizerAdapter.h.

{
    return m_options.optionValue<T>(optionName);
}

References RootMinimizerAdapter::m_options, and OptionContainer::optionValue().

Here is the call graph for this function:

clear()

virtual void IMinimizer::clear ( )

inlinevirtualinherited

clear resources (parameters) for consecutives minimizations

Definition at line 50 of file IMinimizer.h.

{}

Member Data Documentation

m_minuit2_minimizer

std::unique_ptr<ROOT::Minuit2::Minuit2Minimizer> Minuit2Minimizer::m_minuit2_minimizer

private

Definition at line 84 of file Minuit2Minimizer.h.

Referenced by propagateOptions(), and rootMinimizer().

m_options

MinimizerOptions RootMinimizerAdapter::m_options

privateinherited

Definition at line 103 of file RootMinimizerAdapter.h.

Referenced by RootMinimizerAdapter::addOption(), RootMinimizerAdapter::options(), RootMinimizerAdapter::optionValue(), and RootMinimizerAdapter::setOptionValue().

m_minimizerInfo

MinimizerInfo RootMinimizerAdapter::m_minimizerInfo

privateinherited

Definition at line 104 of file RootMinimizerAdapter.h.

Referenced by RootMinimizerAdapter::algorithmName(), and RootMinimizerAdapter::minimizerName().

m_adapter

std::unique_ptr<Fit::ObjectiveFunctionAdapter> RootMinimizerAdapter::m_adapter

privateinherited

Definition at line 105 of file RootMinimizerAdapter.h.

Referenced by RootMinimizerAdapter::minimize(), RootMinimizerAdapter::minimize_residual(), and RootMinimizerAdapter::minimize_scalar().

m_status

bool RootMinimizerAdapter::m_status

privateinherited

Definition at line 106 of file RootMinimizerAdapter.h.

Referenced by RootMinimizerAdapter::minimize(), and RootMinimizerAdapter::statusToString().

---

The documentation for this class was generated from the following files:

• /home/www/ba/Fit/RootAdapter/Minuit2Minimizer.h
• /home/www/ba/Fit/RootAdapter/Minuit2Minimizer.cpp