Add support for locked parameters in curve fitting: implement locking mechanism in FitParam and FitParamDataSet, update autofit methods, and introduce tests for locked parameter functionality

Author: PierreRaybaut

CHANGELOG.md

@@ -4,6 +4,14 @@
 
 💥 New features / Enhancements:
 
+* Curve fitting: added support for locked parameters:
+  * New `locked` parameter in `FitParam` class to lock parameter values during automatic optimization
+  * New `locked` field in `FitParamDataSet` to configure parameter locking via the settings dialog
+  * When locked, parameters retain their manually-adjusted values during auto-fit
+  * Visual indicators: locked parameters show a 🔒 emoji and are grayed out with disabled controls
+  * All optimization algorithms (simplex, Powell, BFGS, L-BFGS-B, conjugate gradient, least squares) fully support locked parameters
+  * Enables partial optimization workflows: fix well-determined parameters, optimize uncertain ones
+  * Improves fit convergence by reducing problem dimensionality
 * Configurable autoscale margin:
   * Added `autoscale_margin_percent` parameter to `BasePlotOptions` for intuitive percentage-based margin control
   * Users can now specify autoscale margins as percentages (e.g., `0.2` for 0.2%, `5.0` for 5%)

plotpy/locale/fr/LC_MESSAGES/plotpy.po

@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: plotpy 2.7.4\n"
 "Report-Msgid-Bugs-To: p.raybaut@codra.fr\n"
-"POT-Creation-Date: 2025-10-08 11:19+0200\n"
+"POT-Creation-Date: 2025-10-18 16:38+0200\n"
 "PO-Revision-Date: 2025-06-02 11:14+0200\n"
 "Last-Translator: Christophe Debonnel <c.debonnel@codra.fr>\n"
 "Language: fr\n"
@@ -1604,6 +1604,9 @@ msgstr "Format"
 msgid "Logarithmic"
 msgstr "Logarithmique"
 
+msgid "Fixed value during optimization"
+msgstr "Valeur fixe pendant l'optimisation"
+
 msgid "Curve fitting parameter"
 msgstr "Paramètre d'ajustement"
 

plotpy/tests/features/test_fit_locked_params.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Test script for locked fit parameters feature"""
+
+import numpy as np
+
+from plotpy.widgets.fit import FitParam, guifit
+
+
+def test_locked_fit():
+    """Test the curve fitting tool with locked parameters"""
+    # Generate test data: y = cos(1.5*x) + 0.2
+    x = np.linspace(-10, 10, 1000)
+    true_offset = 0.2
+    true_freq = 1.5
+    y = np.cos(true_freq * x) + true_offset + np.random.rand(x.shape[0]) * 0.1
+
+    def fit(x, params):
+        """Fit function: a + cos(b*x)"""
+        a, b = params
+        return np.cos(b * x) + a
+
+    # Create fit parameters
+    # Lock the frequency parameter at the true value
+    a = FitParam("Offset", 0.0, -1.0, 1.0)
+    b = FitParam("Frequency", true_freq, 0.3, 3.0, logscale=True, locked=True)
+
+    params = [a, b]
+
+    print("Initial values:")
+    print(f"  Offset (unlocked): {a.value}")
+    print(f"  Frequency (locked): {b.value}")
+
+    values = guifit(
+        x,
+        y,
+        fit,
+        params,
+        xlabel="Time (s)",
+        ylabel="Amplitude (a.u.)",
+        wintitle="Locked Parameter Test",
+        auto_fit=True,
+    )
+
+    if values:
+        print("\nFinal values after fit:")
+        print(f"  Offset: {values[0]:.4f} (should be close to {true_offset})")
+        print(f"  Frequency: {values[1]:.4f} (should remain {true_freq})")
+        print("\nNote: The frequency parameter was locked and should not have changed.")
+        print("Only the offset parameter should have been optimized.")
+
+
+if __name__ == "__main__":
+    test_locked_fit()

plotpy/widgets/fit.py

@@ -125,6 +125,7 @@ class FitParamDataSet(DataSet):
     format = StringItem(_("Format"), default="%.3f").set_pos(col=1)
     logscale = BoolItem(_("Logarithmic"), _("Scale"))
     unit = StringItem(_("Unit"), default="").set_pos(col=1)
+    locked = BoolItem(_("Fixed value during optimization"), _("Lock"))
 
 
 class FitParam:
@@ -140,6 +141,8 @@ class FitParam:
         format: format of the parameter. Default is "%.3f".
         size_offset: size offset of the parameter. Default is 0.
         unit: unit of the parameter. Default is "".
+        locked: if True, the parameter value is locked and will not be modified
+            by the automatic fit. Default is False.
     """
 
     def __init__(
@@ -153,6 +156,7 @@ def __init__(
         format: str = "%.3f",
         size_offset: int = 0,
         unit: str = "",
+        locked: bool = False,
     ):
         self.name = name
         self.value = value
@@ -162,6 +166,7 @@ def __init__(
         self.steps = steps
         self.format = format
         self.unit = unit
+        self.locked = locked
         self.prefix_label = None
         self.lineedit = None
         self.unit_label = None
@@ -188,6 +193,7 @@ def copy(self) -> FitParam:
             self.format,
             self._size_offset,
             self.unit,
+            self.locked,
         )
 
     def create_widgets(self, parent: QWidget, refresh_callback: Callable) -> None:
@@ -258,6 +264,8 @@ def set_text(self, fmt: str = None) -> None:
             fmt: format (default: None)
         """
         style = "<span style='color: #444444'><b>{}</b></span>"
+        if self.locked:
+            style = "<span style='color: #888888'><b>{} 🔒</b></span>"
         self.prefix_label.setText(style.format(self.name))
         if self.value is None:
             value_str = ""
@@ -266,7 +274,10 @@ def set_text(self, fmt: str = None) -> None:
                 fmt = self.format
             value_str = fmt % self.value
         self.lineedit.setText(value_str)
-        self.lineedit.setDisabled(bool(self.value == self.min and self.max == self.min))
+        is_disabled = bool(
+            self.locked or (self.value == self.min and self.max == self.min)
+        )
+        self.lineedit.setDisabled(is_disabled)
 
     def line_editing_finished(self):
         """Line editing finished"""
@@ -303,7 +314,7 @@ def update_slider_value(self):
         elif self.value == self.min and self.max == self.min:
             self.slider.hide()
         else:
-            self.slider.setEnabled(True)
+            self.slider.setEnabled(not self.locked)
             if self.slider.parentWidget() and self.slider.parentWidget().isVisible():
                 self.slider.show()
             if self.logscale:
@@ -666,40 +677,73 @@ def compute_imin_imax(self) -> None:
         self.i_min = self.x.searchsorted(self.autofit_prm.xmin)
         self.i_max = self.x.searchsorted(self.autofit_prm.xmax, side="right")
 
-    def errorfunc(self, params: list[float]) -> np.ndarray:
+    def get_full_params(self, free_params: np.ndarray) -> list[float]:
+        """Build full parameter list from free parameters
+
+        Args:
+            free_params: values of unlocked parameters only
+
+        Returns:
+            Full parameter list with locked parameters at their fixed values
+        """
+        full_params = []
+        free_idx = 0
+        for p in self.fitparams:
+            if p.locked:
+                full_params.append(p.value)
+            else:
+                full_params.append(free_params[free_idx])
+                free_idx += 1
+        return full_params
+
+    def errorfunc(self, free_params: np.ndarray) -> np.ndarray:
         """Get error function
 
         Args:
-            params: fit parameter values
+            free_params: values of unlocked fit parameters
 
         Returns:
             Error function
         """
         x = self.x[self.i_min : self.i_max]
         y = self.y[self.i_min : self.i_max]
         fitargs, fitkwargs = self.get_fitfunc_arguments()
+        params = self.get_full_params(free_params)
         return y - self.fitfunc(x, params, *fitargs, **fitkwargs)
 
     def autofit(self) -> None:
         """Autofit"""
         meth = self.autofit_prm.method
-        x0 = np.array([p.value for p in self.fitparams])
+
+        # Extract only unlocked parameters for optimization
+        free_params = np.array([p.value for p in self.fitparams if not p.locked])
+
+        # If all parameters are locked, nothing to optimize
+        if len(free_params) == 0:
+            return
+
         if meth == "lq":
-            x = self.autofit_lq(x0)
+            x = self.autofit_lq(free_params)
         elif meth == "simplex":
-            x = self.autofit_simplex(x0)
+            x = self.autofit_simplex(free_params)
         elif meth == "powel":
-            x = self.autofit_powel(x0)
+            x = self.autofit_powel(free_params)
         elif meth == "bfgs":
-            x = self.autofit_bfgs(x0)
+            x = self.autofit_bfgs(free_params)
         elif meth == "l_bfgs_b":
-            x = self.autofit_l_bfgs(x0)
+            x = self.autofit_l_bfgs(free_params)
         elif meth == "cg":
-            x = self.autofit_cg(x0)
+            x = self.autofit_cg(free_params)
         else:
             return
-        for v, p in zip(x, self.fitparams):
-            p.value = v
+
+        # Restore optimized values only to unlocked parameters
+        free_idx = 0
+        for p in self.fitparams:
+            if not p.locked:
+                p.value = x[free_idx]
+                free_idx += 1
+
         self.refresh()
         for prm in self.fitparams:
             prm.update()
@@ -776,7 +820,8 @@ def autofit_l_bfgs(self, x0: np.ndarray) -> np.ndarray:
             Fitted values
         """
         prm = self.autofit_prm
-        bounds = [(p.min, p.max) for p in self.fitparams]
+        # Build bounds only for unlocked parameters
+        bounds = [(p.min, p.max) for p in self.fitparams if not p.locked]
 
         x, _f, _d = fmin_l_bfgs_b(
             self.get_norm_func(), x0, pgtol=prm.gtol, approx_grad=1, bounds=bounds