New MinimizerLibrary catalogue with the description of abailable minimization algorithms.

Core/Tools/BornAgainNamespace.h

@@ -203,6 +203,27 @@ const std::string Thickness = "Thickness";
 const std::string Hurst = "Hurst";
 const std::string CorrelationLength = "CorrelationLength";
 const std::string CrossCorrelationLength = "CrossCorrelationLength";
+
+// Minimizer related
+const std::string MinuitMinimizerType = "MinuitMinimizer";
+const std::string GSLMinimizerType = "GSLMinimizer";
+const std::string GeneticMinimizerType = "GeneticMinimizer";
+
+const std::string MigradAlgorithmType = "Migrad";
+const std::string SimplexAlgorithmType = "Simplex";
+const std::string CombinedAlgorithmType = "Combined";
+const std::string ScanAlgorithmType = "Scan";
+const std::string FumiliAlgorithmType = "Fumili";
+
+const std::string ConjugateFRAlgorithmType = "ConjugateFR";
+const std::string ConjugatePRAlgorithmType = "ConjugatePR";
+const std::string BFGSAlgorithmType = "BFGS";
+const std::string BFGS2AlgorithmType = "BFGS2";
+const std::string LMAAlgorithmType = "LMA";
+const std::string SimAnAlgorithmType = "SimAn";
+
+const std::string GeneticAlgorithmType = "Genetic";
+
 }
 
 #endif // BORNAGAINNAMESPACE_H

Fit/FitKernel/MinimizerLibrary.cpp

+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/FitKernel/MinimizerLibrary.cpp
+//! @brief     Implements namespace MinimizerLibrary.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#include "MinimizerLibrary.h"
+#include "Exceptions.h"
+#include "BornAgainNamespace.h"
+
+using namespace MinimizerLibrary;
+
+AlgorithmInfo::AlgorithmInfo(const std::string &algType, const std::string &algDescription)
+    : InfoItem(algType, algDescription)
+{
+}
+
+MinimizerInfo::MinimizerInfo(const std::string &minimizerType,
+                             const std::string &minimizerDescription)
+    : InfoItem(minimizerType, minimizerDescription)
+{
+
+}
+
+void MinimizerInfo::addAlgorithm(const MinimizerLibrary::AlgorithmInfo &algorithm)
+{
+    m_algorithms.push_back(algorithm);
+}
+
+void MinimizerInfo::addAlgorithm(const std::string &algorithmName,
+                                               const std::string &algorithmDescription)
+{
+    addAlgorithm(AlgorithmInfo(algorithmName, algorithmDescription));
+}
+
+//! Return list of algorithm types.
+
+std::list<std::string> MinimizerInfo::algorithmTypes() const
+{
+    std::list<std::string> result;
+    for(AlgorithmInfo algo : m_algorithms) {
+        result.push_back(algo.getType());
+    }
+    return result;
+}
+
+//! Returns list of string with description of all available algorithms.
+
+std::list<std::string> MinimizerInfo::algorithmDescriptions() const
+{
+    std::list<std::string> result;
+    for(AlgorithmInfo algo : m_algorithms) {
+        result.push_back(algo.getDescription());
+    }
+    return result;
+}
+
+//! Catalogue constructor fills in all information related to available minimizers/algorithms.
+
+Catalogue::Catalogue()
+{
+    MinimizerInfo minuit(BornAgain::MinuitMinimizerType, "Minuit2 minimizer from ROOT library");
+    minuit.addAlgorithm(
+        BornAgain::MigradAlgorithmType,
+        "Variable-metric method with inexact line search, best minimizer according to ROOT.");
+    minuit.addAlgorithm(BornAgain::SimplexAlgorithmType, "Simplex method of Nelder and Meadh, "
+                                                         "robust against big fluctuations in "
+                                                         "objective function.");
+    minuit.addAlgorithm(BornAgain::CombinedAlgorithmType,
+                        "Combination of Migrad and Simplex (if Migrad fails).");
+    minuit.addAlgorithm(BornAgain::ScanAlgorithmType,
+                        "Simple objective function scan, one parameter at a time.");
+    minuit.addAlgorithm(BornAgain::FumiliAlgorithmType, "Gradient descent minimizer similar to "
+                                                        "Levenberg-Margquardt, sometimes can be "
+                                                        "better than all others.");
+    addMinimizer(minuit);
+
+    MinimizerInfo gsl(BornAgain::GSLMinimizerType, "Set of minimizers from GNU Scientific Library");
+    gsl.addAlgorithm(BornAgain::ConjugateFRAlgorithmType, "Fletcher-Reeves conjugate gradient");
+    gsl.addAlgorithm(BornAgain::ConjugatePRAlgorithmType, "Polak-Ribiere conjugate gradient");
+    gsl.addAlgorithm(BornAgain::BFGSAlgorithmType, "BFGS conjugate gradient");
+    gsl.addAlgorithm(BornAgain::BFGS2AlgorithmType, "BFGS conjugate gradient (Version 2)");
+    gsl.addAlgorithm(BornAgain::LMAAlgorithmType, "Levenberg-Marquardt, often works quite well.");
+    gsl.addAlgorithm(BornAgain::SimAnAlgorithmType, "Simulated Annealing");
+    addMinimizer(gsl);
+
+    MinimizerInfo genetic(BornAgain::GeneticMinimizerType, "TMVA Genetic Algorithm");
+    genetic.addAlgorithm(BornAgain::GeneticAlgorithmType, "TMVA Genetic Algorithm");
+    addMinimizer(genetic);
+}
+
+//! Adds minimizer info to the catalogue.
+
+void Catalogue::addMinimizer(const MinimizerInfo &minimizer)
+{
+    auto it = m_minimizers.find(minimizer.getType());
+    if(it==m_minimizers.end()) {
+        m_minimizers[minimizer.getType()] = minimizer;
+    } else {
+        throw LogicErrorException("Catalogue::addMinimizer() -> Error. Attempt to add twice "
+                                  " minimizer " + minimizer.getType());
+    }
+}
+
+//! Returns list of algorithm types for given minimizer type.
+
+std::list<std::string> Catalogue::algorithmTypes(const std::string &minimizerType)
+{
+    MinimizerInfo minimizer = minimizerInfo(minimizerType);
+    return  minimizer.algorithmTypes();
+}
+
+//! Returns list of algorithm descriptions for given minimizer type.
+
+std::list<std::string> Catalogue::algorithmDescriptions(const std::string &minimizerType)
+{
+    MinimizerInfo minimizer = minimizerInfo(minimizerType);
+    return  minimizer.algorithmDescriptions();
+}
+
+//! Returns minimizer info for given minimizer type.
+
+MinimizerLibrary::MinimizerInfo Catalogue::minimizerInfo(const std::string &minimizerType)
+{
+    auto it = m_minimizers.find(minimizerType);
+    if(it == m_minimizers.end()) {
+        throw LogicErrorException("Catalogue::addMinimizer() -> Error. Non existing minimizer "
+                                  + minimizerType);
+    }
+    return m_minimizers[minimizerType];
+}

Fit/FitKernel/MinimizerLibrary.h

+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      Fit/FitKernel/MinimizerLibrary.h
+//! @brief     Declares namespace MinimizerLibrary.
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2015
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
+//
+// ************************************************************************** //
+
+#ifndef MINIMIZERLIBRARY_H
+#define MINIMIZERLIBRARY_H
+
+#include "WinDllMacros.h"
+#include <list>
+#include <string>
+#include <map>
+
+//! The MinimizerLibrary namespace contains set of classes to form the catalogue of
+//! available minimizers, their algorithms and short descriptions.
+
+namespace MinimizerLibrary {
+
+//! @class InfoItem
+//! @ingroup fitting_internal
+//! @brief Simple item to hold the name and the description.
+
+class BA_CORE_API_ InfoItem {
+public:
+    InfoItem(){}
+    InfoItem(const std::string &itemType, const std::string &itemDescription)
+        : m_itemType(itemType)
+        , m_itemDescription(itemDescription){}
+
+    std::string getType() const { return m_itemType; }
+    std::string getDescription() const { return m_itemDescription; }
+private:
+    std::string m_itemType;
+    std::string m_itemDescription;
+};
+
+//! @class AlgorithmInfo
+//! @ingroup fitting_internal
+//! @brief Provides description of minimization algorithm.
+
+class BA_CORE_API_ AlgorithmInfo : public InfoItem {
+public:
+    AlgorithmInfo(){}
+    AlgorithmInfo(const std::string &algType, const std::string &algDescription);
+};
+
+//! @class MinimizerInfo
+//! @ingroup fitting_internal
+//! @brief Provides info about the minimizer, including list of defined minimization algorithms.
+
+class BA_CORE_API_ MinimizerInfo : public InfoItem {
+public:
+    MinimizerInfo(){}
+    MinimizerInfo(const std::string &minimizerType, const std::string &minimizerDescription);
+
+    void addAlgorithm(const AlgorithmInfo &algorithm);
+    void addAlgorithm(const std::string &algorithmName, const std::string &algorithmDescription);
+
+    std::list<std::string> algorithmTypes() const;
+    std::list<std::string> algorithmDescriptions() const;
+
+private:
+    std::list<AlgorithmInfo> m_algorithms;
+};
+
+//! @class MinimizerInfo
+//! @ingroup fitting_internal
+//! @brief Holds all information about available minimization engines.
+
+class BA_CORE_API_ Catalogue {
+public:
+    Catalogue();
+
+    void addMinimizer(const MinimizerInfo &minimizer);
+
+    std::list<std::string> algorithmTypes(const std::string &minimizerType);
+    std::list<std::string> algorithmDescriptions(const std::string &minimizerType);
+
+private:
+    MinimizerInfo minimizerInfo(const std::string &minimizerType);
+
+    std::map<std::string, MinimizerInfo> m_minimizers;
+};
+
+} // MinimizerLibrary namespace
+
+#endif

GUI/coregui/Models/MinimizerItem.cpp

@@ -15,13 +15,17 @@
 // ************************************************************************** //
 
 #include "MinimizerItem.h"
+#include "MinimizerItemCatalogue.h"
+#include "ComboProperty.h"
 
 const QString MinimizerItem::P_MINIMIZER_LIBRARY = "Library";
+const QString MinimizerItem::P_ALGORITHMS = "Algorithms";
 
 MinimizerItem::MinimizerItem()
     : SessionItem(Constants::MinimizerType)
 {
-    addGroupProperty(P_MINIMIZER_LIBRARY, Constants::MinimizerLibraryGroup);
+    addGroupProperty(P_MINIMIZER_LIBRARY, Constants::MinimizerLibraryGroup)
+        ->setToolTip(QStringLiteral("Minimizer library"));
     addProperty("test", 99.0);
 
 }
@@ -31,8 +35,8 @@ MinimizerItem::MinimizerItem()
 MinuitMinimizerItem::MinuitMinimizerItem()
     : SessionItem(Constants::MinuitMinimizerType)
 {
-    addProperty("A", 1.0);
-
+    addProperty(MinimizerItem::P_ALGORITHMS,
+        MinimizerItemCatalogue::getAlgorithmCombo(Constants::MinuitMinimizerType).getVariant());
 }
 
 // ----------------------------------------------------------------------------
@@ -40,13 +44,15 @@ MinuitMinimizerItem::MinuitMinimizerItem()
 GSLMinimizerItem::GSLMinimizerItem()
     : SessionItem(Constants::GSLMinimizerType)
 {
-    addProperty("B", 2.0);
+    addProperty(MinimizerItem::P_ALGORITHMS,
+        MinimizerItemCatalogue::getAlgorithmCombo(Constants::GSLMinimizerType).getVariant());
 
 }
 
 GeneticMinimizerItem::GeneticMinimizerItem()
     : SessionItem(Constants::GeneticMinimizerType)
 {
-    addProperty("C", 3.0);
+    addProperty(MinimizerItem::P_ALGORITHMS,
+        MinimizerItemCatalogue::getAlgorithmCombo(Constants::GeneticMinimizerType).getVariant());
 
 }

GUI/coregui/Models/MinimizerItem.h

@@ -25,6 +25,7 @@ class BA_CORE_API_ MinimizerItem : public SessionItem
 {
 public:
     static const QString P_MINIMIZER_LIBRARY;
+    static const QString P_ALGORITHMS;
     explicit MinimizerItem();
 };
 

GUI/coregui/Models/MinimizerItemCatalogue.cpp

+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      GUI/coregui/Models/MinimizerItemCatalogue.cpp
+//! @brief     Implements MinimizerItemCatalogue class
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2016
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   Céline Durniak, Marina Ganeva, David Li, Gennady Pospelov
+//! @authors   Walter Van Herck, Joachim Wuttke
+//
+// ************************************************************************** //
+
+#include "MinimizerItemCatalogue.h"
+#include "GUIHelpers.h"
+
+MinimizerLibrary::Catalogue MinimizerItemCatalogue::m_catalogue = MinimizerLibrary::Catalogue();
+
+//! Returns ComboProperty representing list of algorithms defined for given minimizerType.
+
+ComboProperty MinimizerItemCatalogue::getAlgorithmCombo(const QString &minimizerType)
+{
+    ComboProperty result;
+
+    std::list<std::string> algos = m_catalogue.algorithmTypes(minimizerType.toStdString());
+    result << GUIHelpers::fromStdList(algos);
+
+    std::list<std::string> descr = m_catalogue.algorithmDescriptions(minimizerType.toStdString());
+    result.setToolTips(GUIHelpers::fromStdList(descr));
+
+    return result;
+}

GUI/coregui/Models/MinimizerItemCatalogue.h

+// ************************************************************************** //
+//
+//  BornAgain: simulate and fit scattering at grazing incidence
+//
+//! @file      GUI/coregui/Models/MinimizerItemCatalogue.h
+//! @brief     Declares MinimizerItemCatalogue class
+//!
+//! @homepage  http://www.bornagainproject.org
+//! @license   GNU General Public License v3 or higher (see COPYING)
+//! @copyright Forschungszentrum Jülich GmbH 2016
+//! @authors   Scientific Computing Group at MLZ Garching
+//! @authors   Céline Durniak, Marina Ganeva, David Li, Gennady Pospelov
+//! @authors   Walter Van Herck, Joachim Wuttke
+//
+// ************************************************************************** //
+
+#ifndef MINIMIZERITEMCATALOGUE_H
+#define MINIMIZERITEMCATALOGUE_H
+
+#include "WinDllMacros.h"
+#include "MinimizerLibrary.h"
+#include "ComboProperty.h"
+#include <QStringList>
+
+//! The MinimizerItemCatalogue class is a static class to provide MinimizerItem
+//! with the list of available minimizers/algorithms. It is a bridge class which
+//! extract all necessary information from Core's MinimizerLibrary.
+
+
+class BA_CORE_API_ MinimizerItemCatalogue {
+public:
+
+    static ComboProperty getAlgorithmCombo(const QString &minimizerType);
+private:
+    static MinimizerLibrary::Catalogue m_catalogue;
+};
+
+#endif

GUI/coregui/Models/SessionItem.cpp

@@ -447,7 +447,7 @@ void SessionItem::setItemValue(const QString &tag, const QVariant &variant)
      getItem(tag)->setValue(variant);
 }
 
-//! Creates new group item and register new tag.
+//! Creates new group item and register new tag, returns GroupItem.
 
 SessionItem *SessionItem::addGroupProperty(const QString &groupName, const QString &groupType)
 {

GUI/coregui/utils/GUIHelpers.cpp

@@ -219,5 +219,14 @@ QString currentDateTime()
     return QDateTime::currentDateTime().toString("yyyy.MM.dd hh:mm:ss");;
 }
 
+QStringList fromStdList(const std::list<std::string> &string_list)
+{
+    QStringList result;
+    for(std::string str : string_list) {
+        result.append(QString::fromStdString(str));
+    }
+    return result;
+}
+
 
 } // namespace GUIHelpers

GUI/coregui/utils/GUIHelpers.h

@@ -70,6 +70,8 @@ BA_CORE_API_ bool isVersionMatchMinimal(const QString &version, const QString &m
 
 BA_CORE_API_ QString currentDateTime();
 
+BA_CORE_API_ QStringList fromStdList(const std::list<std::string> &string_list);
+
 template<class T, class... Ts> std::unique_ptr<T> make_unique(Ts&&... params)
 {
     return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));