RootMinimizerAdapter Class Reference

Inheritance diagram for RootMinimizerAdapter:

Collaboration diagram for RootMinimizerAdapter:

Public Types
typedef ROOT::Math::Minimizer	root_minimizer_t

Public Member Functions
virtual	~RootMinimizerAdapter () 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
virtual std::string	statusToString () const
bool	providesError () const
virtual std::map< std::string, std::string >	statusMap () const
void	setOptions (const std::string &optionString) override final
virtual void	clear ()
virtual bool	requiresResiduals ()

Protected Member Functions
	RootMinimizerAdapter (const MinimizerInfo &minimizerInfo)
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
virtual void	propagateOptions ()=0
virtual const root_minimizer_t *	rootMinimizer () const =0
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
MinimizerOptions	m_options
MinimizerInfo	m_minimizerInfo
std::unique_ptr< Fit::ObjectiveFunctionAdapter >	m_adapter
bool	m_status

Detailed Description

Pure virtual interface that adapts the CERN ROOT minimizer to our IMinimizer.

Definition at line 43 of file RootMinimizerAdapter.h.

Member Typedef Documentation

root_minimizer_t

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

Definition at line 46 of file RootMinimizerAdapter.h.

Constructor & Destructor Documentation

~RootMinimizerAdapter()

RootMinimizerAdapter::~RootMinimizerAdapter ( )

overridevirtualdefault

RootMinimizerAdapter()

RootMinimizerAdapter::RootMinimizerAdapter ( const MinimizerInfo &  minimizerInfo )

protected

Definition at line 25 of file RootMinimizerAdapter.cpp.

    : m_minimizerInfo(minimizerInfo), m_adapter(new Fit::ObjectiveFunctionAdapter), m_status(false)
{
}

Member Function Documentation

minimize_scalar()

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

overridevirtual

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 m_adapter, minimize(), and rootMinimizer().

Here is the call graph for this function:

minimize_residual()

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

overridevirtual

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 m_adapter, minimize(), and rootMinimizer().

Here is the call graph for this function:

minimizerName()

std::string RootMinimizerAdapter::minimizerName ( ) const

finaloverridevirtual

Returns name of the minimizer.

Implements IMinimizer.

Definition at line 64 of file RootMinimizerAdapter.cpp.

{
    return m_minimizerInfo.name();
}

References 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

finaloverridevirtual

Returns name of the minimization algorithm.

Implements IMinimizer.

Definition at line 69 of file RootMinimizerAdapter.cpp.

{
    return m_minimizerInfo.algorithmName();
}

References MinimizerInfo::algorithmName(), and m_minimizerInfo.

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

Here is the call graph for this function:

setParameters()

void RootMinimizerAdapter::setParameters

(

const Fit::Parameters &

parameters

)

Definition at line 74 of file RootMinimizerAdapter.cpp.

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

References setParameter().

Referenced by minimize().

Here is the call graph for this function:

minValue()

double RootMinimizerAdapter::minValue ( ) const

finaloverridevirtual

Returns minimum function value.

Reimplemented from IMinimizer.

Definition at line 81 of file RootMinimizerAdapter.cpp.

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

References rootMinimizer().

Referenced by minimize(), and statusMap().

Here is the call graph for this function:

options() [1/2]

MinimizerOptions& RootMinimizerAdapter::options ( )

inline

Definition at line 63 of file RootMinimizerAdapter.h.

{ return m_options; }

References m_options.

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

options() [2/2]

const MinimizerOptions& RootMinimizerAdapter::options ( ) const

inline

Definition at line 64 of file RootMinimizerAdapter.h.

{ return m_options; }

References m_options.

statusToString()

std::string RootMinimizerAdapter::statusToString ( ) const

virtual

Returns string representation of current minimizer status.

Reimplemented in Minuit2Minimizer, GSLMultiMinimizer, GSLLevenbergMarquardtMinimizer, and GeneticMinimizer.

Definition at line 86 of file RootMinimizerAdapter.cpp.

{
    return m_status ? "Minimum found" : "Error in solving";
}

References m_status.

Referenced by statusMap().

providesError()

bool RootMinimizerAdapter::providesError

(

)

const

Returns true if minimizer provides error and error matrix.

Definition at line 91 of file RootMinimizerAdapter.cpp.

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

References rootMinimizer().

Referenced by propagateResults(), and statusMap().

Here is the call graph for this function:

statusMap()

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

virtual

Returns map of string representing different minimizer statuses.

Reimplemented in SimAnMinimizer, Minuit2Minimizer, GSLLevenbergMarquardtMinimizer, and GeneticMinimizer.

Definition at line 96 of file RootMinimizerAdapter.cpp.

{
    std::map<std::string, std::string> result;
    result["Status"] = statusToString();
 
    if (providesError())
        result["ProvidesError"] = "Provides parameters error and error matrix";
    else
        result["ProvidesError"] = "Doesn't provide error calculation";
 
    result["MinValue"] = StringUtils::scientific(minValue());
 
    return result;
}

References minValue(), providesError(), StringUtils::scientific(), and statusToString().

Referenced by anonymous_namespace{MinimizerResultUtils.cpp}::reportStatus(), GeneticMinimizer::statusMap(), GSLLevenbergMarquardtMinimizer::statusMap(), Minuit2Minimizer::statusMap(), and SimAnMinimizer::statusMap().

Here is the call graph for this function:

setOptions()

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

finaloverridevirtual

Sets option string to the minimizer.

Reimplemented from IMinimizer.

Definition at line 111 of file RootMinimizerAdapter.cpp.

{
    options().setOptionString(optionString);
}

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

Here is the call graph for this function:

minimize()

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

protected

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 m_adapter, m_status, minValue(), propagateOptions(), propagateResults(), MinimizerResultUtils::reportToString(), rootMinimizer(), Fit::MinimizerResult::setMinValue(), Fit::MinimizerResult::setNumberOfCalls(), Fit::MinimizerResult::setNumberOfGradientCalls(), setParameters(), Fit::MinimizerResult::setParameters(), and Fit::MinimizerResult::setReport().

Referenced by minimize_residual(), and minimize_scalar().

Here is the call graph for this function:

propagateResults()

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

protected

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 fitDimension(), parErrorsAtMinimum(), parValuesAtMinimum(), providesError(), rootMinimizer(), Fit::Parameters::setCorrelationMatrix(), Fit::Parameters::setErrors(), and Fit::Parameters::setValues().

Referenced by minimize().

Here is the call graph for this function:

setParameter()

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

protectedvirtual

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(), rootMinimizer(), Fit::Parameter::step(), AttLimits::upperLimit(), and Fit::Parameter::value().

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

Here is the call graph for this function:

fitDimension()

size_t RootMinimizerAdapter::fitDimension ( ) const

protected

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

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

Here is the call graph for this function:

parValuesAtMinimum()

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

protected

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

Referenced by propagateResults().

Here is the call graph for this function:

parErrorsAtMinimum()

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

protected

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

Referenced by propagateResults().

Here is the call graph for this function:

propagateOptions()

virtual void RootMinimizerAdapter::propagateOptions ( )

protectedpure virtual

Implemented in SimAnMinimizer, Minuit2Minimizer, GSLMultiMinimizer, GSLLevenbergMarquardtMinimizer, and GeneticMinimizer.

Referenced by minimize().

rootMinimizer() [1/2]

virtual const root_minimizer_t* RootMinimizerAdapter::rootMinimizer ( ) const

protectedpure virtual

Implemented in SimAnMinimizer, Minuit2Minimizer, GSLMultiMinimizer, GSLLevenbergMarquardtMinimizer, and GeneticMinimizer.

Referenced by fitDimension(), minimize(), minimize_residual(), minimize_scalar(), minValue(), parErrorsAtMinimum(), parValuesAtMinimum(), propagateResults(), providesError(), rootMinimizer(), and setParameter().

rootMinimizer() [2/2]

RootMinimizerAdapter::root_minimizer_t * RootMinimizerAdapter::rootMinimizer ( )

protected

Definition at line 207 of file RootMinimizerAdapter.cpp.

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

References 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 = ""  )

protected

Definition at line 110 of file RootMinimizerAdapter.h.

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

References OptionContainer::addOption(), and m_options.

Referenced by GeneticMinimizer::GeneticMinimizer(), GSLLevenbergMarquardtMinimizer::GSLLevenbergMarquardtMinimizer(), GSLMultiMinimizer::GSLMultiMinimizer(), Minuit2Minimizer::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  )

protected

Definition at line 116 of file RootMinimizerAdapter.h.

{
    m_options.setOptionValue(optionName, value);
}

References m_options, and OptionContainer::setOptionValue().

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

Here is the call graph for this function:

optionValue()

template<class T >

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

protected

Definition at line 121 of file RootMinimizerAdapter.h.

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

References 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.

{}

requiresResiduals()

virtual bool IMinimizer::requiresResiduals ( )

inlinevirtualinherited

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

Reimplemented in Minuit2Minimizer, and GSLLevenbergMarquardtMinimizer.

Definition at line 60 of file IMinimizer.h.

{ return false; }

Member Data Documentation

m_options

MinimizerOptions RootMinimizerAdapter::m_options

private

Definition at line 103 of file RootMinimizerAdapter.h.

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

m_minimizerInfo

MinimizerInfo RootMinimizerAdapter::m_minimizerInfo

private

Definition at line 104 of file RootMinimizerAdapter.h.

Referenced by algorithmName(), and minimizerName().

m_adapter

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

private

Definition at line 105 of file RootMinimizerAdapter.h.

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

m_status

bool RootMinimizerAdapter::m_status

private

Definition at line 106 of file RootMinimizerAdapter.h.

Referenced by minimize(), and statusToString().

---

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

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