MinimizerItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Job/MinimizerItem.cpp
//! @brief     Implements MinimizerItem class
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Job/MinimizerItem.h"
#include "Fit/Adapter/GSLLevenbergMarquardtMinimizer.h"
#include "Fit/Adapter/GSLMultiMinimizer.h"
#include "Fit/Adapter/GeneticMinimizer.h"
#include "Fit/Adapter/Minuit2Minimizer.h"
#include "Fit/Adapter/SimAnMinimizer.h"
#include "GUI/Model/CatJob/MinimizerItemCatalog.h"
#include "Sim/Fitting/ObjectiveMetric.h"
#include "Sim/Fitting/ObjectiveMetricUtils.h"
 
namespace {
 
GroupInfo createMinimizerLibraryGroup()
{
    GroupInfo info;
    info.add(MinuitMinimizerItem::M_TYPE, "Minuit2");
    info.add(GSLMultiMinimizerItem::M_TYPE, "GSL MultiMin");
    info.add(GeneticMinimizerItem::M_TYPE, "TMVA Genetic");
    info.add(SimAnMinimizerItem::M_TYPE, "GSL Simulated Annealing");
    info.add(GSLLMAMinimizerItem::M_TYPE, "GSL Levenberg-Marquardt");
    info.setDefaultType(MinuitMinimizerItem::M_TYPE);
    return info;
}
 
} // namespace
 
 
MinimizerItem::MinimizerItem(const QString& model_type)
    : SessionItem(model_type)
{
}
 
// ----------------------------------------------------------------------------
 
MinimizerContainerItem::MinimizerContainerItem()
    : MinimizerItem(M_TYPE)
{
    static const GroupInfo minimizerLibraryGroup = createMinimizerLibraryGroup();
    addGroupProperty(P_MINIMIZERS, minimizerLibraryGroup)->setToolTip("Minimizer library");
 
    ComboProperty metric_combo;
    for (auto& item : ObjectiveMetricUtils::metricNames())
        metric_combo << QString::fromStdString(item);
    metric_combo.setValue(QString::fromStdString(ObjectiveMetricUtils::defaultMetricName()));
    addProperty(P_METRIC, metric_combo.variant())
        ->setToolTip("Objective metric to use for estimating distance between simulated and "
                     "experimental data.");
 
    ComboProperty norm_combo;
    for (auto& item : ObjectiveMetricUtils::normNames())
        norm_combo << QString::fromStdString(item);
    norm_combo.setValue(QString::fromStdString(ObjectiveMetricUtils::defaultNormName()));
    addProperty(P_NORM, norm_combo.variant())
        ->setToolTip("Normalization to use for estimating distance between simulated and "
                     "experimental data.");
}
 
SelectionDescriptor<MinimizerItem*> MinimizerContainerItem::minimizers() const
{
    return SelectionDescriptor<MinimizerItem*>(item<GroupItem>(P_MINIMIZERS));
}
 
SelectionDescriptor<QString> MinimizerContainerItem::normFunction() const
{
    return SelectionDescriptor<QString>(getItem(P_NORM));
}
 
SelectionDescriptor<QString> MinimizerContainerItem::objectiveMetric() const
{
    return SelectionDescriptor<QString>(getItem(P_METRIC));
}
 
std::unique_ptr<IMinimizer> MinimizerContainerItem::createMinimizer() const
{
    return groupItem<MinimizerItem>(P_MINIMIZERS).createMinimizer();
}
 
std::unique_ptr<ObjectiveMetric> MinimizerContainerItem::createMetric() const
{
    QString metric = getItemValue(P_METRIC).value<ComboProperty>().getValue();
    QString norm = getItemValue(P_NORM).value<ComboProperty>().getValue();
    return ObjectiveMetricUtils::createMetric(metric.toStdString(), norm.toStdString());
}
 
// ----------------------------------------------------------------------------
 
MinuitMinimizerItem::MinuitMinimizerItem()
    : MinimizerItem(M_TYPE)
{
    addProperty(P_ALGORITHMS, MinimizerItemCatalog::algorithmCombo(modelType()).variant());
 
    addProperty(P_STRATEGY, 1)
        ->setToolTip("Minimization strategy (0-low, 1-medium, 2-high quality)");
 
    addProperty(P_ERRORDEF, 1.0)
        ->setToolTip("Error definition factor for parameter error calculation");
 
    addProperty(P_TOLERANCE, 0.01)->setToolTip("Tolerance on the function value at the minimum");
 
    addProperty(P_PRECISION, -1.0)->setToolTip("Relative floating point arithmetic precision");
 
    // Minimizer internal print level is working to std::cout and is not intercepted by GUI
    //    addProperty(P_PRINTLEVEL, 0)->setToolTip("Minimizer internal print level");
 
    addProperty(P_MAXFUNCTIONCALLS, 0)->setToolTip("Maximum number of function calls");
}
 
std::unique_ptr<IMinimizer> MinuitMinimizerItem::createMinimizer() const
{
    QString algorithmName = getItemValue(P_ALGORITHMS).value<ComboProperty>().getValue();
 
    auto* domainMinimizer = new Minuit2Minimizer(algorithmName.toStdString());
    domainMinimizer->setStrategy(getItemValue(P_STRATEGY).toInt());
    domainMinimizer->setErrorDefinition(getItemValue(P_ERRORDEF).toDouble());
    domainMinimizer->setTolerance(getItemValue(P_TOLERANCE).toDouble());
    domainMinimizer->setPrecision(getItemValue(P_PRECISION).toDouble());
    domainMinimizer->setMaxFunctionCalls(getItemValue(P_MAXFUNCTIONCALLS).toInt());
 
    return std::unique_ptr<IMinimizer>(domainMinimizer);
}
 
ValueDescriptors MinuitMinimizerItem::valueDescriptorsForUI() const
{
    return {
        SelectionDescriptor<QString>(getItem(P_ALGORITHMS)),
        UIntDescriptor(getItem(P_STRATEGY), Unit::unitless),
        DoubleDescriptor(getItem(P_ERRORDEF), Unit::unitless),
        DoubleDescriptor(getItem(P_TOLERANCE), Unit::unitless),
        DoubleDescriptor(getItem(P_PRECISION), Unit::unitless),
        UIntDescriptor(getItem(P_MAXFUNCTIONCALLS), Unit::unitless),
    };
}
 
// ----------------------------------------------------------------------------
 
GSLMultiMinimizerItem::GSLMultiMinimizerItem()
    : MinimizerItem(M_TYPE)
{
    addProperty(P_ALGORITHMS, MinimizerItemCatalog::algorithmCombo(modelType()).variant());
    addProperty(P_MAXITERATIONS, 0)->setToolTip("Maximum number of iterations");
}
 
std::unique_ptr<IMinimizer> GSLMultiMinimizerItem::createMinimizer() const
{
    QString algorithmName = getItemValue(P_ALGORITHMS).value<ComboProperty>().getValue();
 
    auto* domainMinimizer = new GSLMultiMinimizer(algorithmName.toStdString());
    domainMinimizer->setMaxIterations(getItemValue(P_MAXITERATIONS).toInt());
    return std::unique_ptr<IMinimizer>(domainMinimizer);
}
 
ValueDescriptors GSLMultiMinimizerItem::valueDescriptorsForUI() const
{
    return {
        SelectionDescriptor<QString>(getItem(P_ALGORITHMS)),
        UIntDescriptor(getItem(P_MAXITERATIONS), Unit::unitless),
    };
}
 
// ----------------------------------------------------------------------------
 
GeneticMinimizerItem::GeneticMinimizerItem()
    : MinimizerItem(M_TYPE)
{
    addProperty(P_TOLERANCE, 0.01)->setToolTip("Tolerance on the function value at the minimum");
    addProperty(P_MAXITERATIONS, 3)->setToolTip("Maximum number of iterations");
    addProperty(P_POPULATIONSIZE, 300)->setToolTip("Population size");
    addProperty(P_RANDOMSEED, 0)->setToolTip("Random seed");
}
 
std::unique_ptr<IMinimizer> GeneticMinimizerItem::createMinimizer() const
{
    auto* domainMinimizer = new GeneticMinimizer();
    domainMinimizer->setTolerance(getItemValue(P_TOLERANCE).toDouble());
    domainMinimizer->setMaxIterations(getItemValue(P_MAXITERATIONS).toInt());
    domainMinimizer->setPopulationSize(getItemValue(P_POPULATIONSIZE).toInt());
    domainMinimizer->setRandomSeed(getItemValue(P_RANDOMSEED).toInt());
    return std::unique_ptr<IMinimizer>(domainMinimizer);
}
 
ValueDescriptors GeneticMinimizerItem::valueDescriptorsForUI() const
{
    return {
        DoubleDescriptor(getItem(P_TOLERANCE), Unit::unitless),
        UIntDescriptor(getItem(P_MAXITERATIONS), Unit::unitless),
        UIntDescriptor(getItem(P_POPULATIONSIZE), Unit::unitless),
        UIntDescriptor(getItem(P_RANDOMSEED), Unit::unitless),
    };
}
 
// ----------------------------------------------------------------------------
 
SimAnMinimizerItem::SimAnMinimizerItem()
    : MinimizerItem(M_TYPE)
{
    addProperty(P_MAXITERATIONS, 100)->setToolTip("Number of points to try for each step");
    addProperty(P_ITERATIONSTEMP, 10)->setToolTip("Number of iterations at each temperature");
    addProperty(P_STEPSIZE, 1.0)->setToolTip("Max step size used in random walk");
    addProperty(P_BOLTZMANN_K, 1.0)->setToolTip("Boltzmann k");
    addProperty(P_BOLTZMANN_TINIT, 50.0)->setToolTip("Boltzmann initial temperature");
    addProperty(P_BOLTZMANN_MU, 1.05)->setToolTip("Boltzmann mu");
    addProperty(P_BOLTZMANN_TMIN, 0.1)->setToolTip("Boltzmann minimal temperature");
}
 
std::unique_ptr<IMinimizer> SimAnMinimizerItem::createMinimizer() const
{
    auto* domainMinimizer = new SimAnMinimizer();
    domainMinimizer->setMaxIterations(getItemValue(P_MAXITERATIONS).toInt());
    domainMinimizer->setIterationsAtEachTemp(getItemValue(P_ITERATIONSTEMP).toInt());
    domainMinimizer->setStepSize(getItemValue(P_STEPSIZE).toDouble());
    domainMinimizer->setBoltzmannK(getItemValue(P_BOLTZMANN_K).toDouble());
    domainMinimizer->setBoltzmannInitialTemp(getItemValue(P_BOLTZMANN_TINIT).toDouble());
    domainMinimizer->setBoltzmannMu(getItemValue(P_BOLTZMANN_MU).toDouble());
    domainMinimizer->setBoltzmannMinTemp(getItemValue(P_BOLTZMANN_TMIN).toDouble());
    return std::unique_ptr<IMinimizer>(domainMinimizer);
}
 
ValueDescriptors SimAnMinimizerItem::valueDescriptorsForUI() const
{
    return {
        UIntDescriptor(getItem(P_MAXITERATIONS), Unit::unitless),
        UIntDescriptor(getItem(P_ITERATIONSTEMP), Unit::unitless),
        DoubleDescriptor(getItem(P_STEPSIZE), Unit::unitless),
        DoubleDescriptor(getItem(P_BOLTZMANN_K), Unit::unitless),
        DoubleDescriptor(getItem(P_BOLTZMANN_TINIT), Unit::unitless),
        DoubleDescriptor(getItem(P_BOLTZMANN_MU), Unit::unitless),
        DoubleDescriptor(getItem(P_BOLTZMANN_TMIN), Unit::unitless),
    };
}
 
// ----------------------------------------------------------------------------
 
GSLLMAMinimizerItem::GSLLMAMinimizerItem()
    : MinimizerItem(M_TYPE)
{
    addProperty(P_TOLERANCE, 0.01)->setToolTip("Tolerance on the function value at the minimum");
    addProperty(P_MAXITERATIONS, 0)->setToolTip("Maximum number of iterations");
}
 
std::unique_ptr<IMinimizer> GSLLMAMinimizerItem::createMinimizer() const
{
    auto* domainMinimizer = new GSLLevenbergMarquardtMinimizer();
    domainMinimizer->setTolerance(getItemValue(P_TOLERANCE).toDouble());
    domainMinimizer->setMaxIterations(getItemValue(P_MAXITERATIONS).toInt());
    return std::unique_ptr<IMinimizer>(domainMinimizer);
}
 
ValueDescriptors GSLLMAMinimizerItem::valueDescriptorsForUI() const
{
    return {
        DoubleDescriptor(getItem(P_TOLERANCE), Unit::unitless),
        UIntDescriptor(getItem(P_MAXITERATIONS), Unit::unitless),
    };
}