diff --git a/App/src/TestFittingModule4.cpp b/App/src/TestFittingModule4.cpp
index e0a97ada61fe20031f1b6de86369eee11aa57d37..4c90a674b54650cbbb9b94c6189cadc536d70247 100644
--- a/App/src/TestFittingModule4.cpp
+++ b/App/src/TestFittingModule4.cpp
@@ -66,13 +66,15 @@ void TestFittingModule4::execute()
     //m_fitSuite->setMinimizer( MinimizerFactory::createMinimizer("Scan") );
 
 
-    ROOTMinimizer *root_minimizer = dynamic_cast<ROOTMinimizer *>(m_fitSuite->getMinimizer());
-    ROOT::Math::Minimizer *minim = root_minimizer->getROOTMinimizer();
+    m_fitSuite->getMinimizer()->getOptions().setPrintLevel(10);
 
+
+//    ROOTMinimizer *root_minimizer = dynamic_cast<ROOTMinimizer *>(m_fitSuite->getMinimizer());
+//    ROOT::Math::Minimizer *minim = root_minimizer->getROOTMinimizer();
     //minim->SetMaxFunctionCalls(100);
     //minim->SetMaxIterations(100);
+//    minim->SetPrintLevel(10);
 
-    minim->SetPrintLevel(10);
 
 //    ROOT::Math::MinimizerOptions options = minim->Options();
 //    options.Print();
@@ -98,10 +100,17 @@ void TestFittingModule4::execute()
 //    std::cout << "---" << std::endl;
 //    minim->Options().Print();
 
+    m_fitSuite->getMinimizer()->getOptions().setMaxIterations(5);
+    m_fitSuite->getMinimizer()->getOptions().setValue("Steps",5);
+//    m_fitSuite->getMinimizer()->getOptions().setValue("PopSize",100);
+//    m_fitSuite->getMinimizer()->getOptions().setTolerance(100);
+
+//    m_fitSuite->getMinimizer()->getOptions().setValue("ntries",50);
+//    m_fitSuite->getMinimizer()->getOptions().setValue("niters_fixed_t",5);
 //    m_fitSuite->getMinimizer()->getOptions().setMaxIterations(5);
-//    m_fitSuite->getMinimizer()->getOptions().setValue("Steps",5);
-//    m_fitSuite->getMinimizer()->getOptions().setValue("PopSize",1000);
-    m_fitSuite->getMinimizer()->getOptions().setTolerance(0.1);
+
+
+    m_fitSuite->getMinimizer()->getOptions().print();
 
 
     m_fitSuite->attachObserver( FitSuiteObserverFactory::createPrintObserver(100) );
@@ -162,6 +171,8 @@ void TestFittingModule4::initializeSample()
 
     m_fitSuite->addFitParameter("*height", 2.*Units::nanometer, 0.04*Units::nanometer, AttLimits::limited(0.01, 30.) );
     m_fitSuite->addFitParameter("*radius", 20.*Units::nanometer, 0.06*Units::nanometer, AttLimits::limited(0.01, 30.) );
+//    m_fitSuite->addFitParameter("*height", 6.*Units::nanometer, 0.04*Units::nanometer, AttLimits::limited(0.01, 30.) );
+//    m_fitSuite->addFitParameter("*radius", 6.*Units::nanometer, 0.06*Units::nanometer, AttLimits::limited(0.01, 30.) );
 }
 
 
diff --git a/Fit/CMakeLists.txt b/Fit/CMakeLists.txt
index ccd312bc109365d3b7f7f9526db7ee2f30f76962..d8fa58266a14297cd38ea7fb8e6125609dbacf6d 100644
--- a/Fit/CMakeLists.txt
+++ b/Fit/CMakeLists.txt
@@ -18,11 +18,18 @@ file(GLOB include_files
     "FitKernel/inc/*.h"
 )
 
+# genetic minimizer only available if ROOT present
+if(NOT ROOT_FOUND)
+    list(REMOVE_ITEM source_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/src/ROOTGeneticMinimizer.cpp")
+    list(REMOVE_ITEM include_files "${CMAKE_CURRENT_SOURCE_DIR}/FitKernel/inc/ROOTGeneticMinimizer.h")
+endif()
+
 if(BORNAGAIN_PYTHON)
     file(GLOB source_pythonapi "PythonAPI/src/*.cpp")
     list(APPEND source_files ${source_pythonapi})
     file(GLOB include_pythonapi "PythonAPI/inc/*.h")
     list(APPEND include_files ${include_pythonapi})
+
     include_directories(
         ${CMAKE_CURRENT_SOURCE_DIR}/PythonAPI/inc
     )
diff --git a/Fit/FitKernel/inc/MinimizerOptions.h b/Fit/FitKernel/inc/MinimizerOptions.h
index 2caf307b1a98ebc6eeb294148766d8e16c49defa..01b68448731b1ad64423609ceb426d6d8755d257 100644
--- a/Fit/FitKernel/inc/MinimizerOptions.h
+++ b/Fit/FitKernel/inc/MinimizerOptions.h
@@ -19,6 +19,8 @@
 #include "Exceptions.h"
 #include <string>
 #include <map>
+#include <iostream>
+#include <iomanip>
 
 //! @class MinimizerOptions
 //! @ingroup fitting
@@ -52,15 +54,21 @@ public:
     //! set maximum number of allowed function calls
     void setMaxFunctionCalls(int max_function_calls) { m_max_function_calls = max_function_calls; }
 
+    //! return internal print level of the minimizer
+    int getPrintLevel() const { return m_print_level; }
+    //! set internal print level of the minimizer
+    void setPrintLevel(int print_level){ m_print_level = print_level; }
+
     //! set option value
-//    void setValue(const std::string &name, double val) { setRealValue(name, val);}
-//    void setValue(const std::string &name, int val) { setIntValue(name, val);}
-//    void setValue(const std::string &name, const std::string &val) { setNamedValue(name, val);}
 
     void setValue(const std::string &name, double val) { setExistingValue(name, m_RealOpts, val); }
     void setValue(const std::string &name, int val) { setExistingValue(name, m_IntOpts, val);}
     void setValue(const std::string &name, const std::string &val) { setExistingValue(name, m_NamOpts, val);}
 
+    void getValue(const std::string &name, int &val) { val = getIntValue(name); }
+    void getValue(const std::string &name, double &val) { val = getRealValue(name); }
+    void getValue(const std::string &name, std::string &val) { val = getNamedValue(name); }
+
     void addValue(const std::string &name, double val) { addNewValue(name, m_RealOpts, val); }
     void addValue(const std::string &name, int val) { addNewValue(name, m_IntOpts, val);}
     void addValue(const std::string &name, const std::string &val) { addNewValue(name, m_NamOpts, val);}
@@ -69,11 +77,16 @@ public:
     double getRealValue(const std::string &name) { return getValue(name, m_RealOpts); }
     std::string getNamedValue(const std::string &name) { return getValue(name, m_NamOpts); }
 
-private:
-//    void setRealValue(const std::string &name, double val){ setExistingValue(name, m_RealOpts, val); }
-//    void setIntValue(const std::string &name, int val){ setExistingValue(name, m_IntOpts, val); }
-//    void setNamedValue(const std::string &name, const std::string &val){ setExistingValue(name, m_NamOpts, val); }
+    void print() const {
+        print_common(std::cout);
+        if(m_IntOpts.size() || m_RealOpts.size() || m_NamOpts.size())
+            std::cout << std::setw(25) << std::left << "Extra options " << " : " << std::endl;
+        print_extra(m_IntOpts, std::cout);
+        print_extra(m_RealOpts, std::cout);
+        print_extra(m_NamOpts, std::cout);
+    }
 
+private:
     template<class M>
     static void setExistingValue(const std::string &name, M & opts, const typename M::mapped_type & value) {
        typename M::iterator pos;
@@ -106,6 +119,13 @@ private:
        return  (*pos).second;
     }
 
+    template<class M>
+    static void print_extra( const M & opts, std::ostream & os) {
+       for (typename M::const_iterator pos = opts.begin(); pos != opts.end(); ++pos)
+          os << std::setw(24) << pos->first << " : " << std::setw(15) << pos->second << std::endl;
+    }
+
+    void print_common(std::ostream & os) const;
 
     double m_tolerance; //!< Tolerance on the function value at the minimum.
     //!< the default tolerance value is 0.01 and the minimization will stop
@@ -123,6 +143,8 @@ private:
 
     int m_max_function_calls; //!< Max number of function calls.
 
+    int m_print_level; //!< internal print level of the minimizer, 0- silent
+
     std::map<std::string, double> m_RealOpts; //!< additional map of the real options
     std::map<std::string, int> m_IntOpts; //!< map of the integer options
     std::map<std::string, std::string> m_NamOpts; //!< map of the named options
diff --git a/Fit/FitKernel/inc/ROOTMinimizer.h b/Fit/FitKernel/inc/ROOTMinimizer.h
index d5342dbfde27b38d2543191f67af4e702f298b10..d5430bc42463dcc570e3db75445c1e47b99c91ee 100644
--- a/Fit/FitKernel/inc/ROOTMinimizer.h
+++ b/Fit/FitKernel/inc/ROOTMinimizer.h
@@ -23,7 +23,6 @@
 #include "FitSuiteParameters.h"
 #include <string>
 #include "Math/Minimizer.h"
-#include "Math/Factory.h"
 #include "Math/Functor.h"
 
 
@@ -66,17 +65,25 @@ class BA_CORE_API_ ROOTMinimizer : public IMinimizer
     virtual size_t getNCalls() const;
 
     //! return minimizer options
-    virtual MinimizerOptions &getOptions();
+    virtual MinimizerOptions &getOptions() { return m_options; }
+    virtual const MinimizerOptions &getOptions() const { return m_options; }
 
     //! set minimizer options
     virtual void setOptions(const MinimizerOptions &options);
 
     //! Returns created minimizer
     ROOT::Math::Minimizer *getROOTMinimizer() { return m_root_minimizer; }
+    const ROOT::Math::Minimizer *getROOTMinimizer() const { return m_root_minimizer; }
 
     //! Checks if type of algorithm is Levenberg-Marquardt or similar
     virtual bool isGradientBasedAgorithm() { return false;}
 
+    //! return name of the minimizer
+    virtual std::string getMinimizerName() const { return m_minimizer_name; }
+
+    //! return name of the minimization algorithm
+    virtual std::string getAlgorithmName() const { return m_algo_type; }
+
  protected:
     virtual void propagateOptions();
 
diff --git a/Fit/FitKernel/inc/ROOTMinimizerHelper.h b/Fit/FitKernel/inc/ROOTMinimizerHelper.h
index f04d6b6cda732ffbcdc266b3f7fb2114fc0d8fec..4da05c324b33b47e6a8b65f13528a068f6a3187b 100644
--- a/Fit/FitKernel/inc/ROOTMinimizerHelper.h
+++ b/Fit/FitKernel/inc/ROOTMinimizerHelper.h
@@ -36,9 +36,7 @@ class BA_CORE_API_ ROOTMinimizerHelper
             const std::string& options);
 
     //! Prints results of minimization
-    static void printResults(ROOT::Math::Minimizer *minimizer,
-            const std::string& minimizer_name, const std::string& algo_type);
-
+    static void printResults(const ROOTMinimizer *minimizer);
 
  private:
     //! process single command
@@ -54,13 +52,13 @@ class BA_CORE_API_ ROOTMinimizerHelper
             const std::string& command);
 
     //! Prints minimizer options
-    static void printOptions(ROOT::Math::Minimizer *minimizer);
+    static void printOptions(const ROOT::Math::Minimizer *minimizer);
 
     //! Prints minimizer status
-    static void printStatus(ROOT::Math::Minimizer *minimizer);
+    static void printStatus(const ROOT::Math::Minimizer *minimizer);
 
     //! Prints variables
-    static void printVariables(ROOT::Math::Minimizer *minimizer);
+    static void printVariables(const ROOT::Math::Minimizer *minimizer);
 
 };
 
diff --git a/Fit/FitKernel/src/MinimizerOptions.cpp b/Fit/FitKernel/src/MinimizerOptions.cpp
index 4902ea40267ef8101ff1c17750326b7fbbd7a1cc..ffdf32360243984f9e089c7a3d26e0bd35b93628 100644
--- a/Fit/FitKernel/src/MinimizerOptions.cpp
+++ b/Fit/FitKernel/src/MinimizerOptions.cpp
@@ -14,13 +14,14 @@
 // ************************************************************************** //
 
 #include "MinimizerOptions.h"
-
+#include <iomanip>
 
 MinimizerOptions::MinimizerOptions()
     : m_tolerance(0.01)
     , m_precision(-1)
     , m_max_iterations(0)
     , m_max_function_calls(0)
+    , m_print_level(0)
 {
 
 }
@@ -39,3 +40,14 @@ MinimizerOptions::MinimizerOptions()
 //{
 //    m_NamOpts[name] = val;
 //}
+
+
+void MinimizerOptions::print_common(std::ostream & os) const
+{
+    os << std::setw(24) << std::left << "Tolerance " << " : " << std::setw(15) << m_tolerance << std::endl;
+    os << std::setw(24) << std::left << "Precision " << " : " << std::setw(15) << m_precision << std::endl;
+    os << std::setw(24) << std::left << "MaxIterations " << " : " << std::setw(15) << m_max_iterations << std::endl;
+    os << std::setw(24) << std::left << "MaxFunctionCalls " << " : " << std::setw(15) << m_max_function_calls << std::endl;
+    os << std::setw(24) << std::left << "PrintLevel " << " : " << std::setw(15) << m_print_level << std::endl;
+
+}
diff --git a/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp b/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
index 6992bb3bc09a17bb92b527343b0c23669ffc0214..261a2adc1fe0658a15152cf96e8fe159c4c121c7 100644
--- a/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
+++ b/Fit/FitKernel/src/ROOTGeneticMinimizer.cpp
@@ -51,14 +51,11 @@ void ROOTGeneticMinimizer::setParameter(size_t index, const FitParameter *par)
 // (which has own messy options)
 void ROOTGeneticMinimizer::propagateOptions()
 {
-    m_root_minimizer->SetTolerance(m_options.getTolerance());
-    m_root_minimizer->SetPrecision(m_options.getPrecision());
-    m_root_minimizer->SetMaxFunctionCalls(m_options.getMaxFunctionCalls());
-    m_root_minimizer->SetMaxIterations(m_options.getMaxIterations());
+    ROOTMinimizer::propagateOptions();
 
     if( m_options.getMaxIterations() > 0 && m_options.getMaxIterations() < m_options.getIntValue("Steps")) {
-        msglog(MSG::WARNING) << "ROOTGeneticMinimizer::propagateOptions() -> Warning. Max iterations smaller than Steps";
-        msglog(MSG::WARNING) << "Setting equal to steps " << m_options.getIntValue("Steps");
+        msglog(MSG::WARNING) << "ROOTGeneticMinimizer::propagateOptions() -> Max iterations smaller than Steps. ";
+        msglog(MSG::WARNING) << "Setting equal to steps " << m_options.getIntValue("Steps") << ".";
         m_options.setMaxIterations(m_options.getIntValue("Steps"));
     }
 
@@ -79,5 +76,7 @@ void ROOTGeneticMinimizer::propagateOptions()
     geneticOpt->SetValue("ConvCrit", 10.*m_options.getTolerance());
     geneticOpt->SetValue("SC_factor", m_options.getRealValue("SC_factor"));
 
+    m_genetic_minimizer->SetOptions(options);
+
 }
 
diff --git a/Fit/FitKernel/src/ROOTMinimizer.cpp b/Fit/FitKernel/src/ROOTMinimizer.cpp
index bf49855d59172558e93d98ecb16a56fe192bd098..6cea358eac1752178219b0ceb5eb6acff471a84a 100644
--- a/Fit/FitKernel/src/ROOTMinimizer.cpp
+++ b/Fit/FitKernel/src/ROOTMinimizer.cpp
@@ -170,7 +170,7 @@ std::vector<double > ROOTMinimizer::getErrorOfVariables() const
 
 void ROOTMinimizer::printResults() const
 {
-    ROOTMinimizerHelper::printResults(m_root_minimizer, m_minimizer_name, m_algo_type);
+    ROOTMinimizerHelper::printResults(this);
 }
 
 
@@ -180,10 +180,10 @@ size_t ROOTMinimizer::getNCalls() const
 }
 
 
-MinimizerOptions &ROOTMinimizer::getOptions()
-{
-    return m_options;
-}
+//MinimizerOptions &ROOTMinimizer::getOptions()
+//{
+//    return m_options;
+//}
 
 
 void ROOTMinimizer::setOptions(const MinimizerOptions &options)
@@ -204,6 +204,7 @@ void ROOTMinimizer::propagateOptions()
     m_root_minimizer->SetPrecision(m_options.getPrecision());
     m_root_minimizer->SetMaxFunctionCalls(m_options.getMaxFunctionCalls());
     m_root_minimizer->SetMaxIterations(m_options.getMaxIterations());
+    m_root_minimizer->SetPrintLevel(m_options.getPrintLevel());
 }
 
 
diff --git a/Fit/FitKernel/src/ROOTMinimizerHelper.cpp b/Fit/FitKernel/src/ROOTMinimizerHelper.cpp
index 11b7181c247697e769745337310ed6f3422f0007..35006c2be91cfcfea233267b43baab9e0cb1c7a4 100644
--- a/Fit/FitKernel/src/ROOTMinimizerHelper.cpp
+++ b/Fit/FitKernel/src/ROOTMinimizerHelper.cpp
@@ -126,23 +126,24 @@ bool ROOTMinimizerHelper::processCommandGSLSimAn(ROOT::Patch::GSLSimAnMinimizer
     return success;
 }
 
-
 // Printing minimizer results on the screen
-void ROOTMinimizerHelper::printResults(ROOT::Math::Minimizer *minimizer, const std::string& minimizer_name, const std::string& algo_type)
+void ROOTMinimizerHelper::printResults(const ROOTMinimizer *minimizer)
 {
     std::cout << "--------------------------------------------------------------------------------" << std::endl;
-    std::cout << std::setw(25) << std::left << "  MinimizerType"      << ": " << minimizer_name << std::endl;
-    std::cout << std::setw(25) << std::left << "  MinimizerAlgorithm" << ": " << algo_type << std::endl;
-    printOptions(minimizer);
-    printStatus(minimizer);
-    printVariables(minimizer);
+    std::cout << std::setw(25) << std::left << "  MinimizerType"      << ": " << minimizer->getMinimizerName() << std::endl;
+    std::cout << std::setw(25) << std::left << "  MinimizerAlgorithm" << ": " << minimizer->getAlgorithmName() << std::endl;
+    //printOptions(minimizer->getROOTMinimizer());
+    std::cout << "--- Options --------------------------------------------------------------------" << std::endl;
+    minimizer->getOptions().print();
+    printStatus(minimizer->getROOTMinimizer());
+    printVariables(minimizer->getROOTMinimizer());
     // own print method of the minimizer
     //m_root_minimizer->PrintResults();
 }
 
 
 // print minimizer description
-void ROOTMinimizerHelper::printOptions(ROOT::Math::Minimizer *minimizer)
+void ROOTMinimizerHelper::printOptions(const ROOT::Math::Minimizer *minimizer)
 {
     std::cout << "--- Options --------------------------------------------------------------------" << std::endl;
     ROOT::Math::MinimizerOptions opt = minimizer->Options();
@@ -157,10 +158,11 @@ void ROOTMinimizerHelper::printOptions(ROOT::Math::Minimizer *minimizer)
         std::cout << "--- Extra Options --------------------------------------------------------------" << std::endl;
         opt.ExtraOptions()->Print();
     }
+
 }
 
 
-void ROOTMinimizerHelper::printStatus(ROOT::Math::Minimizer *minimizer)
+void ROOTMinimizerHelper::printStatus(const ROOT::Math::Minimizer *minimizer)
 {
     std::cout << "--- Status --------------------------------------------------------------------- " << std::endl;
     std::map<int, std::string> minimizerStatus;
@@ -199,7 +201,7 @@ void ROOTMinimizerHelper::printStatus(ROOT::Math::Minimizer *minimizer)
 }
 
 
-void ROOTMinimizerHelper::printVariables(ROOT::Math::Minimizer *minimizer)
+void ROOTMinimizerHelper::printVariables(const ROOT::Math::Minimizer *minimizer)
 {
     std::cout << "--- Variables ------------------------------------------------------------------" << std::endl;
     std::cout << std::setw(25) << std::left << "  NumberOfVariables"      << ": "
diff --git a/Fit/FitKernel/src/ROOTMinuit2Minimizer.cpp b/Fit/FitKernel/src/ROOTMinuit2Minimizer.cpp
index 6a3cb888d51add6a55dcf04d0ecbdef4b31c23f8..2d3771c75a47386e0db0f4ea5c234221dd57f150 100644
--- a/Fit/FitKernel/src/ROOTMinuit2Minimizer.cpp
+++ b/Fit/FitKernel/src/ROOTMinuit2Minimizer.cpp
@@ -21,6 +21,10 @@ ROOTMinuit2Minimizer::ROOTMinuit2Minimizer(const std::string& minimizer_name, co
 {
     m_minuit2_minimizer = new ROOT::Minuit2::Minuit2Minimizer(algo_type.c_str());
     m_root_minimizer = m_minuit2_minimizer;
+
+    m_options.addValue("Strategy", 1);
+    m_options.addValue("ErrorDef", 1);
+
 }
 
 
@@ -35,6 +39,8 @@ bool ROOTMinuit2Minimizer::isGradientBasedAgorithm()
 void ROOTMinuit2Minimizer::propagateOptions()
 {
     ROOTMinimizer::propagateOptions();
+    m_minuit2_minimizer->SetStrategy(m_options.getIntValue("Strategy"));
+    m_minuit2_minimizer->SetErrorDef(m_options.getIntValue("ErrorDef"));
 }
 
 
diff --git a/Fit/FitKernel/src/ROOTSimAnMinimizer.cpp b/Fit/FitKernel/src/ROOTSimAnMinimizer.cpp
index 1f97ce0d30cb34bce963f22070adee5b2cedcf41..f3215d3602f3c24b0196f0549213314374bdbe7e 100644
--- a/Fit/FitKernel/src/ROOTSimAnMinimizer.cpp
+++ b/Fit/FitKernel/src/ROOTSimAnMinimizer.cpp
@@ -20,6 +20,15 @@ ROOTSimAnMinimizer::ROOTSimAnMinimizer(const std::string& minimizer_name, const
 {
     m_siman_minimizer = new ROOT::Patch::GSLSimAnMinimizer();
     m_root_minimizer = m_siman_minimizer;
+
+    m_options.addValue("ntries", 100);
+    m_options.addValue("niters_fixed_t", 10);
+    m_options.addValue("step_size", 1.0);
+    m_options.addValue("k", 1.0);
+    m_options.addValue("t_initial", 50.0);
+    m_options.addValue("mu", 1.05);
+    m_options.addValue("t_min", 0.1);
+    m_options.setMaxIterations(100);
 }
 
 
@@ -27,5 +36,13 @@ ROOTSimAnMinimizer::ROOTSimAnMinimizer(const std::string& minimizer_name, const
 void ROOTSimAnMinimizer::propagateOptions()
 {
     ROOTMinimizer::propagateOptions();
-}
 
+    ROOT::Math::GSLSimAnParams& pars = m_siman_minimizer->getSolver().Params();
+    m_options.getValue("ntries", pars.n_tries);
+    m_options.getValue("niters_fixed_t", pars.iters_fixed_T);
+    m_options.getValue("step_size", pars.step_size);
+    m_options.getValue("k", pars.k);
+    m_options.getValue("t_initial", pars.t_initial);
+    m_options.getValue("mu", pars.mu);
+    m_options.getValue("t_min", pars.t_min);
+}
diff --git a/Tests/FunctionalTests/TestPyFit/testfit01.py b/Tests/FunctionalTests/TestPyFit/testfit01.py
index 284c9eeb14a6951e7bea322a9022f40f11ddd28a..0d4bfda215cc44d0a6fb1750107b4613337fa91b 100644
--- a/Tests/FunctionalTests/TestPyFit/testfit01.py
+++ b/Tests/FunctionalTests/TestPyFit/testfit01.py
@@ -26,11 +26,11 @@ cylinder_radius = 5*nanometer
 
 # minimizer name and type of minimization algorithm
 Minimizers = [ 
-    ("Minuit2","Migrad"), 
-    ("Minuit2","Fumili"), 
-    ("GSLMultiMin","BFGS"),
-    ("GSLMultiMin","SteepestDescent"),
-    ("GSLMultiFit",""),
+    ("Minuit2", "Migrad"),
+    ("Minuit2", "Fumili"),
+    ("GSLMultiMin", "BFGS"),
+    ("GSLMultiMin", "SteepestDescent"),
+    ("GSLLMA", ""),
 #    ("GSLSimAn","")
 ]