Update tests

Author: henrikjacobsenfys

examples/component_example.ipynb

@@ -9,10 +9,10 @@
    "source": [
     "import numpy as np\n",
     "\n",
-    "from easydynamics.sample import Gaussian\n",
-    "from easydynamics.sample import Lorentzian\n",
-    "from easydynamics.sample import DampedHarmonicOscillator\n",
-    "from easydynamics.sample import Polynomial\n",
+    "from easydynamics.sample_model import Gaussian\n",
+    "from easydynamics.sample_model import Lorentzian\n",
+    "from easydynamics.sample_model import DampedHarmonicOscillator\n",
+    "from easydynamics.sample_model import Polynomial\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
     "\n",

src/easydynamics/sample_model/components/damped_harmonic_oscillator.py

@@ -92,10 +92,10 @@ def evaluate(self, x: Union[Numeric, sc.Variable]) -> Union[float, np.ndarray]:
                     self.convert_unit(x.unit.name)
                 except Exception as e:
                     raise UnitError(
-                        f"Input x has unit {x.unit}, but DHO component has unit {self._unit}. Failed to convert DHO to {x.unit}."
+                        f"Input x has unit {x.unit}, but DampedHarmonicOscillator component has unit {self._unit}. Failed to convert DampedHarmonicOscillator to {x.unit}."
                     ) from e
                 warnings.warn(
-                    f"Input x has unit {x.unit}, but DHO component has unit {self._unit}. Converting DHO to {x.unit}."
+                    f"Input x has unit {x.unit}, but DampedHarmonicOscillator component has unit {self._unit}. Converting DampedHarmonicOscillator to {x.unit}."
                 )
         else:
             x_in = x

src/easydynamics/sample_model/components/gaussian.py

@@ -153,7 +153,7 @@ def evaluate(self, x: Union[Numeric, sc.Variable]) -> Union[float, np.ndarray]:
         if any(np.isinf(x_in)):
             raise ValueError("Input x contains infinite values.")
 
-        normalization = 1 / np.sqrt(2 * np.pi) * self._width.value
+        normalization = 1 / (np.sqrt(2 * np.pi) * self._width.value)
         exponent = -0.5 * ((x_in - self._center.value) / self._width.value) ** 2
 
         return self._area.value * normalization * np.exp(exponent)

src/easydynamics/sample_model/components/lorentzian.py

@@ -49,7 +49,7 @@ def __init__(
             )
 
         if center is not None and not isinstance(center, Numeric):
-            raise TypeError("center must be None, a number.")
+            raise TypeError("center must be None or a number.")
 
         if isinstance(center, Numeric):
             center = float(center)

src/easydynamics/sample_model/components/voigt.py

@@ -36,8 +36,8 @@ def __init__(
         name: str = "Voigt",
         area: Numeric = 1.0,
         center: Union[Numeric, None] = None,
-        _gaussian_width: Numeric = 1.0,
-        _lorentzian_width: Numeric = 1.0,
+        gaussian_width: Numeric = 1.0,
+        lorentzian_width: Numeric = 1.0,
         unit: Union[str, sc.Unit] = "meV",
     ):
         # Validate inputs
@@ -58,22 +58,20 @@ def __init__(
         if isinstance(center, Numeric):
             center = float(center)
 
-        if not isinstance(_gaussian_width, Numeric):
-            raise TypeError("_gaussian_width must be a number.")
+        if not isinstance(gaussian_width, Numeric):
+            raise TypeError("gaussian_width must be a number.")
 
-        _gaussian_width = float(_gaussian_width)
-        if _gaussian_width <= 0:
-            raise ValueError(
-                "The _gaussian_width of a Voigt must be greater than zero."
-            )
+        gaussian_width = float(gaussian_width)
+        if gaussian_width <= 0:
+            raise ValueError("The gaussian_width of a Voigt must be greater than zero.")
 
-        if not isinstance(_lorentzian_width, Numeric):
-            raise TypeError("_lorentzian_width must be a number.")
+        if not isinstance(lorentzian_width, Numeric):
+            raise TypeError("lorentzian_width must be a number.")
 
-        _lorentzian_width = float(_lorentzian_width)
-        if _lorentzian_width <= 0:
+        lorentzian_width = float(lorentzian_width)
+        if lorentzian_width <= 0:
             raise ValueError(
-                "The _lorentzian_width of a Voigt must be greater than zero."
+                "The lorentzian_width of a Voigt must be greater than zero."
             )
 
         if not isinstance(unit, (str, sc.Unit)):
@@ -96,15 +94,15 @@ def __init__(
             self._center = Parameter(name=name + " center", value=center, unit=unit)
 
         self._gaussian_width = Parameter(
-            name=name + " _gaussian_width",
-            value=_gaussian_width,
+            name=name + " gaussian_width",
+            value=gaussian_width,
             unit=unit,
             min=MINIMUM_WIDTH,
         )
 
         self._lorentzian_width = Parameter(
-            name=name + " _lorentzian_width",
-            value=_lorentzian_width,
+            name=name + " lorentzian_width",
+            value=lorentzian_width,
             unit=unit,
             min=MINIMUM_WIDTH,
         )
@@ -174,14 +172,14 @@ def copy(self, name: Optional[str] = None) -> Voigt:
             name=name,
             area=self._area.value,
             center=self._center.value,
-            _gaussian_width=self._gaussian_width.value,
-            _lorentzian_width=self._lorentzian_width.value,
+            gaussian_width=self._gaussian_width.value,
+            lorentzian_width=self._lorentzian_width.value,
             unit=self._unit,
         )
         model_copy._area.fixed = self._area.fixed
         model_copy._center.fixed = self._center.fixed
-        model_copy.__gaussian_width.fixed = self._gaussian_width.fixed
-        model_copy.__lorentzian_width.fixed = self._lorentzian_width.fixed
+        model_copy._gaussian_width.fixed = self._gaussian_width.fixed
+        model_copy._lorentzian_width.fixed = self._lorentzian_width.fixed
 
         return model_copy
 

tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 import scipp as sc
+from scipp import UnitError
 
 from scipy.integrate import simpson
 
@@ -18,14 +19,14 @@ def dho(self):
         )
 
     def test_initialization(self, dho: DampedHarmonicOscillator):
-        assert dho.name == "TestDHO"
-        assert dho.area.value == 2.0
-        assert dho.center.value == 1.5
-        assert dho.width.value == 0.3
-        assert dho.unit == "meV"
+        assert dho._name == "TestDHO"
+        assert dho._area.value == 2.0
+        assert dho._center.value == 1.5
+        assert dho._width.value == 0.3
+        assert dho._unit == "meV"
 
     def test_input_type_validation_raises(self):
-        with pytest.raises(TypeError, match="area must be a number or a Parameter"):
+        with pytest.raises(TypeError, match="area must be a number"):
             DampedHarmonicOscillator(
                 name="TestDampedHarmonicOscillator",
                 area="invalid",
@@ -34,7 +35,7 @@ def test_input_type_validation_raises(self):
                 unit="meV",
             )
 
-        with pytest.raises(TypeError, match="center must be a number or a Parameter"):
+        with pytest.raises(TypeError, match="center must be a number"):
             DampedHarmonicOscillator(
                 name="TestDampedHarmonicOscillator",
                 area=2.0,
@@ -43,7 +44,7 @@ def test_input_type_validation_raises(self):
                 unit="meV",
             )
 
-        with pytest.raises(TypeError, match="width must be a number or a Parameter"):
+        with pytest.raises(TypeError, match="width must be a number"):
             DampedHarmonicOscillator(
                 name="TestDampedHarmonicOscillator",
                 area=2.0,
@@ -74,21 +75,6 @@ def test_negative_width_raises(self):
                 unit="meV",
             )
 
-    def test_negative_width_raises_in_evaluate(self):
-        test_dho = DampedHarmonicOscillator(
-            name="TestDampedHarmonicOscillator",
-            area=2.0,
-            center=0.5,
-            width=0.6,
-            unit="meV",
-        )
-        test_dho.width.value = -0.6
-        with pytest.raises(
-            ValueError,
-            match="The width of a DampedHarmonicOscillator must be greater than zero.",
-        ):
-            test_dho.evaluate(np.array([0.0, 1.5, 3.0]))
-
     def test_negative_area_warns(self):
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             DampedHarmonicOscillator(
@@ -99,18 +85,6 @@ def test_negative_area_warns(self):
                 unit="meV",
             )
 
-    def test_negative_area_warns_in_evaluate(self):
-        test_dho = DampedHarmonicOscillator(
-            name="TestDampedHarmonicOscillator",
-            area=2.0,
-            center=0.5,
-            width=0.6,
-            unit="meV",
-        )
-        test_dho.area.value = -2.0
-        with pytest.warns(UserWarning, match="may not be physically meaningful"):
-            test_dho.evaluate(np.array([0.0, 1.5, 3.0]))
-
     def test_evaluate(self, dho: DampedHarmonicOscillator):
         x = np.array([0.0, 1.5, 3.0])
         expected = dho.evaluate(x)
@@ -151,20 +125,13 @@ def test_evaluate_with_different_unit(self, dho: DampedHarmonicOscillator):
         )
         np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
 
-    def test_input_as_parameter(self):
-        param_area = Parameter(name="area_param", value=2.0, unit="meV")
-        param_center = Parameter(name="center_param", value=0.5, unit="meV")
-        param_width = Parameter(name="width_param", value=0.6, unit="meV")
-        test_dho = DampedHarmonicOscillator(
-            name="TestDHO",
-            area=param_area,
-            center=param_center,
-            width=param_width,
-            unit="meV",
-        )
-        assert test_dho.area == param_area
-        assert test_dho.center == param_center
-        assert test_dho.width == param_width
+    def test_evaluate_with_incompatible_unit(self, dho: DampedHarmonicOscillator):
+        x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="nm")
+        with pytest.raises(
+            UnitError,
+            match="Input x has unit nm, but DampedHarmonicOscillator component has unit meV. Failed to convert DampedHarmonicOscillator to nm.",
+        ):
+            dho.evaluate(x)
 
     def test_get_parameters(self, dho: DampedHarmonicOscillator):
         params = dho.get_parameters()
@@ -177,39 +144,39 @@ def test_get_parameters(self, dho: DampedHarmonicOscillator):
     def test_area_matches_parameter(self, dho: DampedHarmonicOscillator):
         # WHEN
         x = np.linspace(
-            -dho.center.value - 20 * dho.width.value,
-            dho.center.value + 20 * dho.width.value,
+            -dho._center.value - 20 * dho._width.value,
+            dho._center.value + 20 * dho._width.value,
             5000,
         )
         y = dho.evaluate(x)
         numerical_area = simpson(y, x)
 
         # THEN EXPECT
-        assert numerical_area == pytest.approx(dho.area.value, rel=2e-3)
+        assert numerical_area == pytest.approx(dho._area.value, rel=2e-3)
 
     def test_convert_unit(self, dho: DampedHarmonicOscillator):
         dho.convert_unit("microeV")
 
-        assert dho.unit == "microeV"
-        assert dho.area.value == 2 * 1e3
-        assert dho.center.value == 1.5 * 1e3
-        assert dho.width.value == 0.3 * 1e3
+        assert dho._unit == "microeV"
+        assert dho._area.value == 2 * 1e3
+        assert dho._center.value == 1.5 * 1e3
+        assert dho._width.value == 0.3 * 1e3
 
     def test_copy(self, dho: DampedHarmonicOscillator):
         dho_copy = dho.copy()
         assert dho_copy is not dho
-        assert dho_copy.name == dho.name
+        assert dho_copy.name == "copy of " + dho._name
 
-        assert dho_copy.area.value == dho.area.value
-        assert dho_copy.area.fixed == dho.area.fixed
+        assert dho_copy._area.value == dho._area.value
+        assert dho_copy._area.fixed == dho._area.fixed
 
-        assert dho_copy.center.value == dho.center.value
-        assert dho_copy.center.fixed == dho.center.fixed
+        assert dho_copy._center.value == dho._center.value
+        assert dho_copy._center.fixed == dho._center.fixed
 
-        assert dho_copy.width.value == dho.width.value
-        assert dho_copy.width.fixed == dho.width.fixed
+        assert dho_copy._width.value == dho._width.value
+        assert dho_copy._width.fixed == dho._width.fixed
 
-        assert dho_copy.unit == dho.unit
+        assert dho_copy._unit == dho._unit
 
     def test_repr(self, dho: DampedHarmonicOscillator):
         repr_str = repr(dho)

tests/unit_tests/sample_model/components/test_delta_function.py

@@ -1,6 +1,7 @@
 import pytest
 
 import numpy as np
+from scipp import UnitError
 
 from easydynamics.sample_model import DeltaFunction
 from easyscience.variable import Parameter
@@ -13,21 +14,19 @@ def delta_function(self):
 
     def test_initialization(self, delta_function: DeltaFunction):
         assert delta_function.name == "TestDeltaFunction"
-        assert delta_function.area.value == 2.0
-        assert delta_function.center.value == 0.5
+        assert delta_function._area.value == 2.0
+        assert delta_function._center.value == 0.5
         assert delta_function.unit == "meV"
 
     def test_input_type_validation_raises(self):
-        with pytest.raises(TypeError, match="area must be a number or a Parameter"):
+        with pytest.raises(TypeError, match="area must be a number"):
             DeltaFunction(
                 name="TestDeltaFunction",
                 area="invalid",
                 center=0.5,
                 unit="meV",
             )
-        with pytest.raises(
-            TypeError, match="center must be None, a number or a Parameter"
-        ):
+        with pytest.raises(TypeError, match="center must be None or a number"):
             DeltaFunction(
                 name="TestDeltaFunction",
                 area=2.0,
@@ -55,17 +54,8 @@ def test_center_is_fixed_if_set_to_None(self):
         test_delta = DeltaFunction(
             name="TestDeltaFunction", area=2.0, center=None, unit="meV"
         )
-        assert test_delta.center.value == 0.0
-        assert test_delta.center.fixed is True
-
-    def test_input_as_parameter(self):
-        param_area = Parameter(name="area_param", value=2.0, unit="meV")
-        param_center = Parameter(name="center_param", value=0.5, unit="meV")
-        test_delta = DeltaFunction(
-            name="TestDeltaFunction", area=param_area, center=param_center, unit="meV"
-        )
-        assert test_delta.area == param_area
-        assert test_delta.center == param_center
+        assert test_delta._center.value == 0.0
+        assert test_delta._center.fixed is True
 
     def test_get_parameters(self, delta_function: DeltaFunction):
         params = delta_function.get_parameters()
@@ -78,19 +68,19 @@ def test_convert_unit(self, delta_function: DeltaFunction):
         delta_function.convert_unit("microeV")
 
         assert delta_function.unit == "microeV"
-        assert delta_function.area.value == 2 * 1e3
-        assert delta_function.center.value == 0.5 * 1e3
+        assert delta_function._area.value == 2 * 1e3
+        assert delta_function._center.value == 0.5 * 1e3
 
     def test_copy(self, delta_function: DeltaFunction):
         delta_copy = delta_function.copy()
         assert delta_copy is not delta_function
-        assert delta_copy.name == delta_function.name
+        assert delta_copy.name == "copy of " + delta_function.name
 
-        assert delta_copy.area.value == delta_function.area.value
-        assert delta_copy.area.fixed == delta_function.area.fixed
+        assert delta_copy._area.value == delta_function._area.value
+        assert delta_copy._area.fixed == delta_function._area.fixed
 
-        assert delta_copy.center.value == delta_function.center.value
-        assert delta_copy.center.fixed == delta_function.center.fixed
+        assert delta_copy._center.value == delta_function._center.value
+        assert delta_copy._center.fixed == delta_function._center.fixed
 
         assert delta_copy.unit == delta_function.unit