fix: copy initial parameters in optimize call

docs/usage/3_perform_fit.ipynb

@@ -256,6 +256,23 @@
     "```"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As can be seen, the values of the optimized parameters in the result are again comparable to the original values we saw in {ref}`usage/3_perform_fit:3.1 Define estimator`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimized_parameters = result[\"parameter_values\"]\n",
+    "optimized_parameters"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

src/tensorwaves/optimizer/minuit.py

@@ -1,7 +1,8 @@
 """Minuit2 adapter to the `iminuit.Minuit` package."""
 
 import time
-from typing import Optional
+from copy import deepcopy
+from typing import Dict, Optional
 
 from iminuit import Minuit
 
@@ -21,8 +22,10 @@ def __init__(self, callback: Optional[Callback] = None) -> None:
         if callback is not None:
             self.__callback = callback
 
-    def optimize(self, estimator: Estimator, initial_parameters: dict) -> dict:
-        parameters = initial_parameters
+    def optimize(
+        self, estimator: Estimator, initial_parameters: Dict[str, float]
+    ) -> dict:
+        parameters = deepcopy(initial_parameters)
 
         def __wrapped_function(pars: list) -> float:
             for i, k in enumerate(parameters.keys()):
@@ -49,15 +52,17 @@ def __wrapped_function(pars: list) -> float:
         par_states = minuit.params
         f_min = minuit.fmin
 
-        results: dict = {"params": {}}
+        parameter_values = dict()
+        parameter_errors = dict()
         for i, name in enumerate(parameters.keys()):
-            results["params"][name] = (
-                par_states[i].value,
-                par_states[i].error,
-            )
-
-        # return fit results
-        results["log_lh"] = f_min.fval
-        results["func_calls"] = f_min.ncalls
-        results["time"] = end_time - start_time
-        return results
+            par_state = par_states[i]
+            parameter_values[name] = par_state.value
+            parameter_errors[name] = par_state.error
+
+        return {
+            "parameter_values": parameter_values,
+            "parameter_errors": parameter_errors,
+            "log_likelihood": f_min.fval,
+            "function_calls": f_min.ncalls,
+            "execution_time": end_time - start_time,
+        }

tests/conftest.py

@@ -1,5 +1,7 @@
 # pylint: disable=redefined-outer-name
 
+from copy import deepcopy
+
 import expertsystem as es
 import numpy as np
 import pytest
@@ -8,6 +10,7 @@
 
 from tensorwaves.data.generate import generate_data, generate_phsp
 from tensorwaves.data.tf_phasespace import TFUniformRealNumberGenerator
+from tensorwaves.estimator import UnbinnedNLL
 from tensorwaves.physics.helicity_formalism.amplitude import (
     IntensityBuilder,
     IntensityTF,
@@ -57,7 +60,8 @@ def intensity(
     kinematics: HelicityKinematics,
     phsp_sample: np.ndarray,
 ) -> IntensityTF:
-    model = helicity_model
+    # https://github.com/ComPWA/tensorwaves/issues/171
+    model = deepcopy(helicity_model)
     builder = IntensityBuilder(model.particles, kinematics, phsp_sample)
     return builder.create_intensity(model)
 
@@ -80,6 +84,11 @@ def data_set(
     return kinematics.convert(data_sample)
 
 
+@pytest.fixture(scope="session")
+def estimator(intensity: IntensityTF, data_set: dict) -> UnbinnedNLL:
+    return UnbinnedNLL(intensity, data_set)
+
+
 def __create_model(formalism: str) -> AmplitudeModel:
     result = es.generate_transitions(
         initial_state=("J/psi(1S)", [-1, +1]),

tests/optimizer/test_minuit.py

@@ -4,42 +4,29 @@
 
 from tensorwaves.estimator import UnbinnedNLL
 from tensorwaves.optimizer.minuit import Minuit2
-from tensorwaves.physics.helicity_formalism.amplitude import IntensityTF
 
 
 class TestMinuit2:
     @staticmethod
-    def test_optimize(intensity: IntensityTF, data_set: dict):
-        estimator = UnbinnedNLL(intensity, data_set)
-        assert estimator.parameters == {
-            "strength_incoherent": 1.0,
-            "MesonRadius_J/psi(1S)": 1.0,
-            "MesonRadius_f(0)(500)": 1.0,
-            "MesonRadius_f(0)(980)": 1.0,
-            "Magnitude_J/psi(1S)_to_f(0)(500)_0+gamma_1;f(0)(500)_to_pi0_0+pi0_0;": 1.0,
-            "Phase_J/psi(1S)_to_f(0)(500)_0+gamma_1;f(0)(500)_to_pi0_0+pi0_0;": 0.0,
-            "Magnitude_J/psi(1S)_to_f(0)(980)_0+gamma_1;f(0)(980)_to_pi0_0+pi0_0;": 1.0,
-            "Phase_J/psi(1S)_to_f(0)(980)_0+gamma_1;f(0)(980)_to_pi0_0+pi0_0;": 0.0,
-            "Mass_J/psi(1S)": 3.0969,
-            "Width_J/psi(1S)": 9.29e-05,
-            "Mass_f(0)(500)": 0.475,
-            "Width_f(0)(500)": 0.55,
-            "Mass_f(0)(980)": 0.99,
-            "Width_f(0)(980)": 0.06,
-        }
+    def test_optimize(estimator: UnbinnedNLL):
         free_pars = {
             "Width_f(0)(500)": 0.3,
             "Mass_f(0)(980)": 1,
         }
         optimizer = Minuit2()
         result = optimizer.optimize(estimator, free_pars)
         assert set(result) == {
-            "params",
-            "log_lh",
-            "func_calls",
-            "time",
+            "parameter_values",
+            "parameter_errors",
+            "log_likelihood",
+            "function_calls",
+            "execution_time",
         }
-        assert set(result["params"]) == set(free_pars)
-        assert pytest.approx(result["log_lh"]) == -13379.223862030514
-        assert pytest.approx(free_pars["Width_f(0)(500)"]) == 0.559522579972911
-        assert pytest.approx(free_pars["Mass_f(0)(980)"]) == 0.9901984320598398
+        par_values = result["parameter_values"]
+        par_errors = result["parameter_errors"]
+        assert set(par_values) == set(free_pars)
+        assert pytest.approx(result["log_likelihood"]) == -13379.223862030514
+        assert pytest.approx(par_values["Width_f(0)(500)"]) == 0.55868526502471
+        assert pytest.approx(par_errors["Width_f(0)(500)"]) == 0.01057804923356
+        assert pytest.approx(par_values["Mass_f(0)(980)"]) == 0.990141023090767
+        assert pytest.approx(par_errors["Mass_f(0)(980)"]) == 0.000721352674347

tests/recipe/test_amplitude_creation.py

@@ -1,4 +1,5 @@
 import os
+from copy import deepcopy
 
 import expertsystem.amplitude.model as es
 
@@ -21,7 +22,8 @@ def _generate_phsp(recipe: es.AmplitudeModel, number_of_events: int):
 
 
 def test_helicity(helicity_model: es.AmplitudeModel):
-    model = helicity_model
+    # https://github.com/ComPWA/tensorwaves/issues/171
+    model = deepcopy(helicity_model)
     kinematics = HelicityKinematics.from_model(model)
     masses_is = kinematics.reaction_kinematics_info.initial_state_masses
     masses_fs = kinematics.reaction_kinematics_info.final_state_masses
@@ -37,7 +39,8 @@ def test_helicity(helicity_model: es.AmplitudeModel):
 
 
 def test_canonical(canonical_model: es.AmplitudeModel):
-    model = canonical_model
+    # https://github.com/ComPWA/tensorwaves/issues/171
+    model = deepcopy(canonical_model)
     particles = model.particles
     kinematics = HelicityKinematics.from_model(model)
     phsp_sample = _generate_phsp(model, NUMBER_OF_PHSP_EVENTS)

tests/test_estimator.py

@@ -0,0 +1,22 @@
+from tensorwaves.estimator import UnbinnedNLL
+
+
+class TestUnbinnedNLL:
+    @staticmethod
+    def test_parameters(estimator: UnbinnedNLL):
+        assert estimator.parameters == {
+            "strength_incoherent": 1.0,
+            "MesonRadius_J/psi(1S)": 1.0,
+            "MesonRadius_f(0)(500)": 1.0,
+            "MesonRadius_f(0)(980)": 1.0,
+            "Magnitude_J/psi(1S)_to_f(0)(500)_0+gamma_1;f(0)(500)_to_pi0_0+pi0_0;": 1.0,
+            "Phase_J/psi(1S)_to_f(0)(500)_0+gamma_1;f(0)(500)_to_pi0_0+pi0_0;": 0.0,
+            "Magnitude_J/psi(1S)_to_f(0)(980)_0+gamma_1;f(0)(980)_to_pi0_0+pi0_0;": 1.0,
+            "Phase_J/psi(1S)_to_f(0)(980)_0+gamma_1;f(0)(980)_to_pi0_0+pi0_0;": 0.0,
+            "Mass_J/psi(1S)": 3.0969,
+            "Width_J/psi(1S)": 9.29e-05,
+            "Mass_f(0)(500)": 0.475,
+            "Width_f(0)(500)": 0.55,
+            "Mass_f(0)(980)": 0.99,
+            "Width_f(0)(980)": 0.06,
+        }