GeneticMinimizer Class Reference

Inheritance diagram for GeneticMinimizer:

Collaboration diagram for GeneticMinimizer:

Public Types
typedef ROOT::Math::Minimizer	root_minimizer_t

Public Member Functions
	GeneticMinimizer ()
	~GeneticMinimizer ()
void	setTolerance (double value)
double	tolerance () const
void	setPrintLevel (int value)
int	printLevel () const
void	setMaxIterations (int value)
int	maxIterations () const
void	setPopulationSize (int value)
int	populationSize () const
void	setRandomSeed (int value)
int	randomSeed () const
std::string	statusToString () const override
std::map< std::string, std::string >	statusMap () const 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 ()
virtual bool	requiresResiduals ()

Protected Member Functions
void	propagateOptions () override
const root_minimizer_t *	rootMinimizer () const override
void	setParameter (unsigned int index, const Fit::Parameter &par) override
virtual void	setParameter (unsigned int index, const Fit::Parameter &par)
Fit::MinimizerResult	minimize (Fit::Parameters parameters)
void	propagateResults (Fit::Parameters &parameters)
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::Math::GeneticMinimizer >	m_genetic_minimizer
MinimizerOptions	m_options
MinimizerInfo	m_minimizerInfo
std::unique_ptr< Fit::ObjectiveFunctionAdapter >	m_adapter
bool	m_status

Detailed Description

Wrapper for the CERN ROOT Genetic minimizer.

Definition at line 31 of file GeneticMinimizer.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

GeneticMinimizer()

GeneticMinimizer::GeneticMinimizer

(

)

Definition at line 30 of file GeneticMinimizer.cpp.

    : RootMinimizerAdapter(MinimizerInfo::buildGeneticInfo()),
      m_genetic_minimizer(new ROOT::Math::GeneticMinimizer())
{
    addOption("Tolerance", 0.01, "Tolerance on the function value at the minimum");
    addOption("PrintLevel", 0, "Minimizer internal print level");
    addOption("MaxIterations", 3, "Maximum number of iterations");
    addOption("PopSize", 300, "Population size");
    addOption("RandomSeed", 0, "Random seed");
 
    // Seems it is not used inside Root, no need to expose
    // addOption("Cycles", 3, "Number of cycles");
 
    // It's hard to understand (without going to much into genetics details), what parameters below
    // are doing. So better to not to expose and rely on their internal ROOT's default values.
 
    // addOption("sc_steps", 10, "Spread control steps");
    // addOption("sc_rate", 5, "Spread control rate");
    // addOption("sc_factor", 0.95, "Spread control factor");
}

References RootMinimizerAdapter::addOption().

Here is the call graph for this function:

~GeneticMinimizer()

GeneticMinimizer::~GeneticMinimizer ( )

default

Member Function Documentation

setTolerance()

void GeneticMinimizer::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 53 of file GeneticMinimizer.cpp.

{
    setOptionValue("Tolerance", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

tolerance()

double GeneticMinimizer::tolerance

(

)

const

Definition at line 58 of file GeneticMinimizer.cpp.

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

Referenced by propagateOptions().

setPrintLevel()

void GeneticMinimizer::setPrintLevel

(

int

value

)

Sets minimizer internal print level.

Definition at line 63 of file GeneticMinimizer.cpp.

{
    setOptionValue("PrintLevel", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

printLevel()

int GeneticMinimizer::printLevel

(

)

const

Definition at line 68 of file GeneticMinimizer.cpp.

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

setMaxIterations()

void GeneticMinimizer::setMaxIterations

(

int

value

)

Sets maximum number of iterations to try at each step.

Definition at line 73 of file GeneticMinimizer.cpp.

{
    setOptionValue("MaxIterations", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

maxIterations()

int GeneticMinimizer::maxIterations

(

)

const

Definition at line 78 of file GeneticMinimizer.cpp.

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

Referenced by propagateOptions().

setPopulationSize()

void GeneticMinimizer::setPopulationSize

(

int

value

)

Sets population size.

Definition at line 83 of file GeneticMinimizer.cpp.

{
    setOptionValue("PopSize", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

populationSize()

int GeneticMinimizer::populationSize

(

)

const

Definition at line 88 of file GeneticMinimizer.cpp.

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

Referenced by propagateOptions().

setRandomSeed()

void GeneticMinimizer::setRandomSeed

(

int

value

)

Sets random seed.

Definition at line 93 of file GeneticMinimizer.cpp.

{
    setOptionValue("RandomSeed", value);
}

References RootMinimizerAdapter::setOptionValue().

Here is the call graph for this function:

randomSeed()

int GeneticMinimizer::randomSeed

(

)

const

Definition at line 98 of file GeneticMinimizer.cpp.

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

Referenced by propagateOptions().

statusToString()

std::string GeneticMinimizer::statusToString ( ) const

overridevirtual

Returns string representation of current minimizer status.

Reimplemented from RootMinimizerAdapter.

Definition at line 116 of file GeneticMinimizer.cpp.

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

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

Here is the call graph for this function:

statusMap()

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

overridevirtual

Returns map of string representing different minimizer statuses.

Reimplemented from RootMinimizerAdapter.

Definition at line 121 of file GeneticMinimizer.cpp.

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

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

Here is the call graph for this function:

propagateOptions()

void GeneticMinimizer::propagateOptions ( )

overrideprotectedvirtual

Implements RootMinimizerAdapter.

Definition at line 128 of file GeneticMinimizer.cpp.

{
    ROOT::Math::GeneticMinimizerParameters pars;
    pars.fPopSize = populationSize();
    pars.fNsteps = maxIterations();
    //    pars.fCycles = m_options.getIntValue("Cycles"); // seems it's not used inside ROOT
    //    pars.fSC_steps = m_options.getIntValue("SC_steps"); // no idea what it is doing
    //    pars.fSC_rate = m_options.getIntValue("SC_rate"); // no idea what it is doing
    //    pars.fSC_factor = m_options.getRealValue("SC_factor"); // no idea what it is doing
    const double scale_as_in_root = 10.0;
    pars.fConvCrit = scale_as_in_root * tolerance();
    pars.fSeed = randomSeed();
    m_genetic_minimizer->SetParameters(pars);
}

References m_genetic_minimizer, maxIterations(), populationSize(), randomSeed(), and tolerance().

Here is the call graph for this function:

rootMinimizer() [1/2]

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

overrideprotectedvirtual

Implements RootMinimizerAdapter.

Definition at line 143 of file GeneticMinimizer.cpp.

{
    return m_genetic_minimizer.get();
}

References m_genetic_minimizer.

Referenced by statusMap(), and statusToString().

setParameter() [1/2]

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

overrideprotectedvirtual

Reimplemented from RootMinimizerAdapter.

Definition at line 103 of file GeneticMinimizer.cpp.

{
    if (!par.limits().isFixed() && !par.limits().isLimited()) {
        std::ostringstream ostr;
        ostr << "GeneticMinimizer::setParameter() -> Error! "
             << "Genetic minimizer requires either fixed or "
             << "limited AttLimits::limited(left,right) parameter. "
             << " Parameter name '" << par.name() << "', limits:" << par.limits().toString();
        throw std::runtime_error(ostr.str());
    }
    RootMinimizerAdapter::setParameter(index, par);
}

References AttLimits::isFixed(), AttLimits::isLimited(), Fit::Parameter::limits(), Fit::Parameter::name(), RootMinimizerAdapter::setParameter(), and AttLimits::toString().

Here is the call graph for this function:

setParameter() [2/2]

void RootMinimizerAdapter::setParameter

protected

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

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 Minuit2Minimizer::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:

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

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(), Minuit2Minimizer::setErrorDefinition(), SimAnMinimizer::setIterationsAtEachTemp(), Minuit2Minimizer::setMaxFunctionCalls(), setMaxIterations(), GSLLevenbergMarquardtMinimizer::setMaxIterations(), GSLMultiMinimizer::setMaxIterations(), SimAnMinimizer::setMaxIterations(), setPopulationSize(), Minuit2Minimizer::setPrecision(), setPrintLevel(), GSLLevenbergMarquardtMinimizer::setPrintLevel(), GSLMultiMinimizer::setPrintLevel(), Minuit2Minimizer::setPrintLevel(), SimAnMinimizer::setPrintLevel(), setRandomSeed(), SimAnMinimizer::setStepSize(), Minuit2Minimizer::setStrategy(), 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

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.

{}

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_genetic_minimizer

std::unique_ptr<ROOT::Math::GeneticMinimizer> GeneticMinimizer::m_genetic_minimizer

private

Definition at line 71 of file GeneticMinimizer.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/GeneticMinimizer.h
• /home/www/ba/Fit/RootAdapter/GeneticMinimizer.cpp