MinimizerSettingsWidget: createMinuitEdits done

GUI/Model/Job/MinimizerItem.cpp

@@ -174,14 +174,11 @@ MinuitMinimizerItem::MinuitMinimizerItem()
 
     addProperty(P_ERRORDEF, double(1.0));
 
-    addProperty(P_TOLERANCE, double(0.01))->setToolTip("Tolerance on the function value at the minimum");
-
-    addProperty(P_PRECISION, double(-1.0))->setToolTip("Relative floating point arithmetic precision");
+    addProperty(P_TOLERANCE, double(0.01));
 
-    // 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_PRECISION, double(-1.0));
 
-    addProperty(P_MAXFUNCTIONCALLS, 0)->setToolTip("Maximum number of function calls");
+    addProperty(P_MAXFUNCTIONCALLS, int(0));
 }
 
 QString MinuitMinimizerItem::currentAlgorithm() const

GUI/View/Fit/MinimizerSettingsWidget.cpp

@@ -85,34 +85,9 @@ void MinimizerSettingsWidget::createMimimizerEdits()
     GUI::Util::Layout::clearLayout(m_minimizerLayout);
 #ifdef SIMPLE_MINIMIZER
     // Minuit2
-
-    if(m_currentItem->currentMinimizerM_TYPE() == MinuitMinimizerItem::M_TYPE) {
-
-        MinuitMinimizerItem* minItem = m_currentItem->minimizerItemMinuit();
-        m_minimizerLayout->addRow("Algorithm:", GUI::Util::createComboBox(
-                                 [=] { return minItem->algorithmCombo(); },
-                                 [=](const QString& t) { minItem->setCurrentAlgorithm(t); },
-                                 &m_updaters, "Minimization algorithm"));
-
-        m_minimizerLayout->addRow("Strategy:", GUI::Util::createIntSpinbox(
-                                 [=] { return minItem->strategy(); },
-                                 [=](int v) { minItem->setStrategy(v); },
-                                 &m_updaters, "Minimization strategy (0-low, 1-medium, 2-high quality)",
-                                 RealLimits::limited(0, 2)));
-
-        m_minimizerLayout->addRow("ErrorDef factor:", GUI::Util::createDoubleSpinbox(
-                                 [=] { return minItem->errorDefinition(); },
-                                 [=](double v) { minItem->setErrorDefinition(v); },
-                                 &m_updaters, "Error definition factor for parameter error calculation",
-                                 RealLimits::positive()));
-
-        m_minimizerLayout->addRow("Tolerance:", GUI::Util::createDoubleSpinbox(
-                                 [=] { return minItem->tolerance(); },
-                                 [=](double v) { minItem->setTolerance(v); },
-                                 &m_updaters, "Tolerance on the function value at the minimum",
-                                 RealLimits::positive()));
-
-    } else
+    if(m_currentItem->currentMinimizerM_TYPE() == MinuitMinimizerItem::M_TYPE)
+        createMinuitEdits();
+    else
     // GSL MultiMin
     if(m_currentItem->currentMinimizerM_TYPE() == GSLMultiMinimizerItem::M_TYPE) {
 
@@ -149,6 +124,45 @@ void MinimizerSettingsWidget::createMimimizerEdits()
 #endif
 }
 
+void MinimizerSettingsWidget::createMinuitEdits()
+{
+    MinuitMinimizerItem* minItem = m_currentItem->minimizerItemMinuit();
+    m_minimizerLayout->addRow("Algorithm:", GUI::Util::createComboBox(
+                             [=] { return minItem->algorithmCombo(); },
+                             [=](const QString& t) { minItem->setCurrentAlgorithm(t); },
+                             &m_updaters, "Minimization algorithm"));
+
+    m_minimizerLayout->addRow("Strategy:", GUI::Util::createIntSpinbox(
+                             [=] { return minItem->strategy(); },
+                             [=](int v) { minItem->setStrategy(v); },
+                             &m_updaters, "Minimization strategy (0-low, 1-medium, 2-high quality)",
+                             RealLimits::limited(0, 2)));
+
+    m_minimizerLayout->addRow("ErrorDef factor:", GUI::Util::createDoubleSpinbox(
+                             [=] { return minItem->errorDefinition(); },
+                             [=](double v) { minItem->setErrorDefinition(v); },
+                             &m_updaters, "Error definition factor for parameter error calculation",
+                             RealLimits::positive()));
+
+    m_minimizerLayout->addRow("Tolerance:", GUI::Util::createDoubleSpinbox(
+                             [=] { return minItem->tolerance(); },
+                             [=](double v) { minItem->setTolerance(v); },
+                             &m_updaters, "Tolerance on the function value at the minimum",
+                             RealLimits::positive()));
+
+    m_minimizerLayout->addRow("Precision:", GUI::Util::createDoubleSpinbox(
+                             [=] { return minItem->precision(); },
+                             [=](double v) { minItem->setPrecision(v); },
+                             &m_updaters, "Relative floating point arithmetic precision",
+                             RealLimits::positive()));
+
+    m_minimizerLayout->addRow("Max func calls:", GUI::Util::createIntSpinbox(
+                             [=] { return minItem->maxFuncCalls(); },
+                             [=](int v) { minItem->setMaxFuncCalls(v); },
+                             &m_updaters, "Maximum number of function calls",
+                             RealLimits::nonnegative()));
+}
+
 void MinimizerSettingsWidget::updateUIValues()
 {
     for (const auto& updater : m_updaters)

GUI/View/Fit/MinimizerSettingsWidget.h

@@ -39,6 +39,7 @@ public slots:
 
 private:
     void createMimimizerEdits();
+    void createMinuitEdits();
 
     void updateUIValues();