Fixed bugs and added results tab

Author: adryyan

src/iminuit/qtwidget.py

@@ -4,21 +4,18 @@
 import numpy as np
 from typing import Dict, Any, Callable
 import sys
+from functools import partial
 
-with warnings.catch_warnings():
-    # ipywidgets produces deprecation warnings through use of internal APIs :(
-    warnings.simplefilter("ignore")
-    try:
-        from PyQt6 import QtCore, QtGui, QtWidgets
-        from matplotlib.figure import Figure
-        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
-        from matplotlib import pyplot as plt
-    except ModuleNotFoundError as e:
-        e.msg += (
-            "\n\nPlease install PyQt6, and matplotlib to enable interactive "
-            "outside of Jupyter notebooks."
-        )
-        raise
+try:
+    from PyQt6 import QtCore, QtGui, QtWidgets
+    from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
+    from matplotlib import pyplot as plt
+except ModuleNotFoundError as e:
+    e.msg += (
+        "\n\nPlease install PyQt6, and matplotlib to enable interactive "
+        "outside of Jupyter notebooks."
+    )
+    raise
 
 
 def make_widget(
@@ -31,46 +28,62 @@ def make_widget(
 
 
     class FloatSlider(QtWidgets.QSlider):
+        # Qt sadly does not have a float slider, so we have to
+        # implement one ourselves.
         floatValueChanged = QtCore.pyqtSignal(float)
 
-        def __init__(self):
+        def __init__(self, label):
             super().__init__(QtCore.Qt.Orientation.Horizontal)
             super().setMinimum(0)
-            super().setMaximum(10000)
-            super().setValue(5000)
+            super().setMaximum(int(1e8))
+            super().setValue(int(5e7))
             self._min = 0.0
             self._max = 1.0
+            self._value = 0.5
+            self._label = label
             self.valueChanged.connect(self._emit_float_value_changed)
 
-        def _emit_float_value_changed(self, value):
-            float_value = self._int_to_float(value)
-            self.floatValueChanged.emit(float_value)
+        def _emit_float_value_changed(self, value=None):
+            if value is not None:
+                self._value = self._int_to_float(value)
+            self._label.setText(f"{self._value:.3g}")
+            self.floatValueChanged.emit(self._value)
 
         def _int_to_float(self, value):
-            return self._min + (value / 10000) * (self._max - self._min)
+            return self._min + (value / 1e8) * (self._max - self._min)
 
         def _float_to_int(self, value):
-            return int((value - self._min) / (self._max - self._min) * 10000)
+            return int((value - self._min) / (self._max - self._min) * 1e8)
 
         def setMinimum(self, min_value):
-            val = self.value()
-            if val <= min_value:
-                val = min_value
+            if self._max <= min_value:
+                return
             self._min = min_value
-            self.setValue(val)
+            self.setValue(self._value)
 
         def setMaximum(self, max_value):
-            val = self.value()
-            if val >= max_value:
-                val = max_value
+            if self._min >= max_value:
+                return
             self._max = max_value
-            self.setValue(val)
+            self.setValue(self._value)
 
         def setValue(self, value):
-            super().setValue(self._float_to_int(value))
+            if value < self._min:
+                self._value = self._min
+                super().setValue(0)
+                self._emit_float_value_changed()
+            elif value > self._max:
+                self._value = self._max
+                super().setValue(int(1e8))
+                self._emit_float_value_changed()
+            else:
+                self._value = value
+                self.blockSignals(True)
+                super().setValue(self._float_to_int(value))
+                self.blockSignals(False)
 
         def value(self):
-            return self._int_to_float(super().value())
+            return self._value
 
 
     class Parameter(QtWidgets.QGroupBox):
@@ -96,7 +109,7 @@ def __init__(self, minuit, par, callback):
                 alignment=QtCore.Qt.AlignmentFlag.AlignCenter)
             self.value_label.setMinimumSize(QtCore.QSize(50, 0))
             # Add value slider
-            self.slider = FloatSlider()
+            self.slider = FloatSlider(self.value_label)
             # Add spin boxes for changing the limits
             self.tmin = QtWidgets.QDoubleSpinBox(
                 alignment=QtCore.Qt.AlignmentFlag.AlignCenter)
@@ -151,6 +164,9 @@ def __init__(self, minuit, par, callback):
             self.tmin.setSingleStep(1e-1 * (vmax2 - vmin2))
             self.tmax.setValue(vmax2)
             self.tmax.setSingleStep(1e-1 * (vmax2 - vmin2))
+            # Remember the original values and limits
+            self.original_value = val
+            self.original_limits = (vmin2, vmax2)
             # Set up the slider
             self.slider.setMinimum(vmin2)
             self.slider.setMaximum(vmax2)
@@ -167,15 +183,15 @@ def __init__(self, minuit, par, callback):
             self.fit.clicked.connect(self.on_fit_toggled)
 
         def on_val_change(self, val):
-            print("val change", val)
             self.minuit.values[self.par] = val
-            self.value_label.setText(f"{val:.3g}")
             self.callback()
 
         def on_min_change(self):
             tmin = self.tmin.value()
             if tmin >= self.tmax.value():
+                self.tmin.blockSignals(True)
                 self.tmin.setValue(self.minuit.limits[self.par][0])
+                self.tmin.blockSignals(False)
                 return
             self.slider.setMinimum(tmin)
             lim = self.minuit.limits[self.par]
@@ -184,14 +200,15 @@ def on_min_change(self):
         def on_max_change(self):
             tmax = self.tmax.value()
             if tmax <= self.tmin.value():
+                self.tmax.blockSignals(True)
                 self.tmax.setValue(self.minuit.limits[self.par][1])
+                self.tmax.blockSignals(False)
                 return
             self.slider.setMaximum(tmax)
             lim = self.minuit.limits[self.par]
             minuit.limits[self.par] = (lim[0], tmax)
 
         def on_fix_toggled(self):
-            print("fix toggled")
             self.minuit.fixed[self.par] = self.fix.isChecked()
             if self.fix.isChecked():
                 self.fit.setChecked(False)
@@ -200,18 +217,26 @@ def on_fit_toggled(self):
             self.slider.setEnabled(not self.fit.isChecked())
             if self.fit.isChecked():
                 self.fix.setChecked(False)
-                self.on_fix_toggled()
+                self.minuit.fixed[self.par] = False
             self.callback()
 
-        def reset(self, val, limits=None):
+        def reset(self, val=None, limits=False):
+            if limits:
+                self.slider.blockSignals(True)
+                self.slider.setMinimum(self.original_limits[0])
+                self.slider.blockSignals(True)
+                self.slider.setMaximum(self.original_limits[1])
+                self.tmin.blockSignals(True)
+                self.tmin.setValue(self.original_limits[0])
+                self.tmin.blockSignals(False)
+                self.tmax.blockSignals(True)
+                self.tmax.setValue(self.original_limits[1])
+                self.tmax.blockSignals(False)
+            if val is None:
+                val = self.original_value
             self.slider.blockSignals(True)
             self.slider.setValue(val)
             self.value_label.setText(f"{val:.3g}")
-            if limits:
-                self.slider.setMinimum(limits[0])
-                self.slider.setMaximum(limits[1])
-                self.tmin.setValue(limits[0])
-                self.tmax.setValue(limits[1])
             self.slider.blockSignals(False)
 
 
@@ -257,7 +282,7 @@ def __init__(self):
             button_layout = QtWidgets.QHBoxLayout(button_group)
             self.fit_button = QtWidgets.QPushButton("Fit", parent=button_group)
             self.fit_button.setStyleSheet("background-color: #2196F3; color: white")
-            self.fit_button.clicked.connect(self.do_fit)
+            self.fit_button.clicked.connect(partial(self.do_fit, plot=True))
             button_layout.addWidget(self.fit_button)
             self.update_button = QtWidgets.QPushButton("Continuous", parent=button_group)
             self.update_button.setCheckable(True)
@@ -292,12 +317,12 @@ def __init__(self):
             parameter_layout.addStretch()
             # Results tab
             results_layout = QtWidgets.QVBoxLayout(results_tab)
-            results_text = QtWidgets.QPlainTextEdit(parent=results_tab)
-            font = QtGui.QFont()
-            font.setFamily("FreeMono")
-            results_text.setFont(font)
-            results_text.setReadOnly(True)
-            results_layout.addWidget(results_text)
+            self.results_text = QtWidgets.QTextEdit(parent=results_tab)
+            #font = QtGui.QFont()
+            #font.setFamily("FreeMono")
+            #self.results_text.setFont(font)
+            self.results_text.setReadOnly(True)
+            results_layout.addWidget(self.results_text)
             # Remember the original values and limits
             self.original_values = minuit.values[:]
             self.original_limits = minuit.limits[:]
@@ -325,7 +350,12 @@ def on_parameter_change(self, from_fit=False,
                         minuit.fixed[i] = not x.fit.isChecked()
                     from_fit = True
                     report_success = self.do_fit(plot=False)
+                    self.results_text.clear()
+                    self.results_text.setHtml(minuit._repr_html_())
                     minuit.fixed = saved
+            else:
+                self.results_text.clear()
+                self.results_text.setHtml(minuit._repr_html_())
 
             self.canvas.figure.clear()
             self.plot_with_frame(from_fit, report_success)
@@ -334,7 +364,7 @@ def on_parameter_change(self, from_fit=False,
         def do_fit(self, plot=True):
             report_success = self.fit()
             for i, x in enumerate(self.parameters):
-                x.reset(minuit.values[i])
+                x.reset(val=minuit.values[i])
             if not plot:
                 return report_success
             self.on_parameter_change(
@@ -349,7 +379,7 @@ def on_reset_button_clicked(self):
             minuit.values = self.original_values
             minuit.limits = self.original_limits
             for i, x in enumerate(self.parameters):
-                x.reset(minuit.values[i], minuit.limits[i])
+                x.reset(val=minuit.values[i], limits=True)
             self.on_parameter_change()
 
         def plot_with_frame(self, from_fit, report_success):