Split tests into components

Author: henrikjacobsenfys

tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py

@@ -0,0 +1,221 @@
+import pytest
+
+import numpy as np
+import scipp as sc
+
+from scipy.integrate import simpson
+
+from easydynamics.sample_model import DampedHarmonicOscillator
+
+from easyscience.variable import Parameter
+
+
+class TestDampedHarmonicOscillator:
+    @pytest.fixture
+    def dho(self):
+        return DampedHarmonicOscillator(
+            name="TestDHO", area=2.0, center=1.5, width=0.3, unit="meV"
+        )
+
+    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"
+
+    def test_input_type_validation_raises(self):
+        with pytest.raises(TypeError, match="area must be a number or a Parameter"):
+            DampedHarmonicOscillator(
+                name="TestDampedHarmonicOscillator",
+                area="invalid",
+                center=0.5,
+                width=0.6,
+                unit="meV",
+            )
+
+        with pytest.raises(TypeError, match="center must be a number or a Parameter"):
+            DampedHarmonicOscillator(
+                name="TestDampedHarmonicOscillator",
+                area=2.0,
+                center="invalid",
+                width=0.6,
+                unit="meV",
+            )
+
+        with pytest.raises(TypeError, match="width must be a number or a Parameter"):
+            DampedHarmonicOscillator(
+                name="TestDampedHarmonicOscillator",
+                area=2.0,
+                center=0.5,
+                width="invalid",
+                unit="meV",
+            )
+
+        with pytest.raises(TypeError, match="unit must be a string"):
+            DampedHarmonicOscillator(
+                name="TestDampedHarmonicOscillator",
+                area=2.0,
+                center=0.5,
+                width=0.6,
+                unit=123,
+            )
+
+    def test_negative_width_raises(self):
+        with pytest.raises(
+            ValueError,
+            match="The width of a DampedHarmonicOscillator must be greater than zero.",
+        ):
+            DampedHarmonicOscillator(
+                name="TestDampedHarmonicOscillator",
+                area=2.0,
+                center=0.5,
+                width=-0.6,
+                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(
+                name="TestDampedHarmonicOscillator",
+                area=-2.0,
+                center=0.5,
+                width=0.6,
+                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)
+        expected_result = (
+            2
+            * 2.0
+            * (1.5**2)
+            * (0.3)
+            / np.pi
+            / ((x**2 - 1.5**2) ** 2 + (2 * 0.3 * x) ** 2)
+        )
+        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+
+    def test_evaluate_scipp_array(self, dho: DampedHarmonicOscillator):
+        x = sc.array(dims=["x"], values=[0.0, 1.5, 3.0], unit="meV")
+        expected = dho.evaluate(x)
+        expected_result = (
+            2
+            * 2.0
+            * (1.5**2)
+            * (0.3)
+            / np.pi
+            / ((x.values**2 - 1.5**2) ** 2 + (2 * 0.3 * x.values) ** 2)
+        )
+        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+
+    def test_evaluate_with_different_unit(self, dho: DampedHarmonicOscillator):
+        x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="microeV")
+        expected = dho.evaluate(x)
+        expected_result = (
+            2
+            * 2.0
+            * 1e3
+            * ((1.5 * 1e3) ** 2)
+            * (0.3 * 1e3)
+            / np.pi
+            / ((x.values**2 - (1.5 * 1e3) ** 2) ** 2 + (2 * 0.3 * 1e3 * x.values) ** 2)
+        )
+        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_get_parameters(self, dho: DampedHarmonicOscillator):
+        params = dho.get_parameters()
+        assert len(params) == 3
+        assert params[0].name == "TestDHO area"
+        assert params[1].name == "TestDHO center"
+        assert params[2].name == "TestDHO width"
+        assert all(isinstance(param, Parameter) for param in params)
+
+    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,
+            5000,
+        )
+        y = dho.evaluate(x)
+        numerical_area = simpson(y, x)
+
+        # THEN EXPECT
+        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
+
+    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.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.width.value == dho.width.value
+        assert dho_copy.width.fixed == dho.width.fixed
+
+        assert dho_copy.unit == dho.unit
+
+    def test_repr(self, dho: DampedHarmonicOscillator):
+        repr_str = repr(dho)
+        assert "DampedHarmonicOscillator" in repr_str
+        assert "name = TestDHO" in repr_str
+        assert "unit = meV" in repr_str
+        assert "area =" in repr_str
+        assert "center =" in repr_str
+        assert "width =" in repr_str

tests/unit_tests/sample_model/components/test_delta_function.py

@@ -0,0 +1,103 @@
+import pytest
+
+import numpy as np
+
+from easydynamics.sample_model import DeltaFunction
+from easyscience.variable import Parameter
+
+
+class TestDeltaFunction:
+    @pytest.fixture
+    def delta_function(self):
+        return DeltaFunction(name="TestDeltaFunction", area=2.0, center=0.5, unit="meV")
+
+    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.unit == "meV"
+
+    def test_input_type_validation_raises(self):
+        with pytest.raises(TypeError, match="area must be a number or a Parameter"):
+            DeltaFunction(
+                name="TestDeltaFunction",
+                area="invalid",
+                center=0.5,
+                unit="meV",
+            )
+        with pytest.raises(
+            TypeError, match="center must be None, a number or a Parameter"
+        ):
+            DeltaFunction(
+                name="TestDeltaFunction",
+                area=2.0,
+                center="invalid",
+                unit="meV",
+            )
+        with pytest.raises(TypeError, match="unit must be a string"):
+            DeltaFunction(name="TestDeltaFunction", area=2.0, center=0.5, unit=123)
+
+    def test_negative_area_warns(self):
+        with pytest.warns(UserWarning, match="may not be physically meaningful"):
+            DeltaFunction(name="TestDeltaFunction", area=-2.0, center=0.5, unit="meV")
+
+    @pytest.mark.xfail(
+        reason="DeltaFunction.evaluate is not implemented yet without resolution convolution"
+    )
+    def test_evaluate(self, delta_function: DeltaFunction):
+        x = np.array([0.0, 0.5, 1.0])
+        expected = delta_function.evaluate(x)
+        expected_result = np.zeros_like(x)
+        # expected_result[x == 0.5] = 2.0
+        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+
+    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
+
+    def test_get_parameters(self, delta_function: DeltaFunction):
+        params = delta_function.get_parameters()
+        assert len(params) == 2
+        assert params[0].name == "TestDeltaFunction area"
+        assert params[1].name == "TestDeltaFunction center"
+        assert all(isinstance(param, Parameter) for param in params)
+
+    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
+
+    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.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.unit == delta_function.unit
+
+    def test_repr(self, delta_function: DeltaFunction):
+        repr_str = repr(delta_function)
+        assert "DeltaFunction" in repr_str
+        assert "name = TestDeltaFunction" in repr_str
+        assert "unit = meV" in repr_str
+        assert "area =" in repr_str
+        assert "center =" in repr_str