And a few more tests

Author: henrikjacobsenfys

src/easydynamics/sample/components.py

@@ -364,7 +364,7 @@ def __init__(
 
     def evaluate(self, x: Union[Numeric, sc.Variable]) -> Union[float, np.ndarray]:
         if self.width.value <= 0:
-            raise ValueError("Width must be greater than zero for Lorentzian.")
+            raise ValueError("The width of a Lorentzian must be greater than zero.")
         if self.area.value < 0:
             warnings.warn(
                 "The area of the Lorentzian with name {} is negative, which may not be physically meaningful.".format(
@@ -522,12 +522,10 @@ def __init__(
 
     def evaluate(self, x: Union[Numeric, sc.Variable]) -> Union[float, np.ndarray]:
         if self.gaussian_width.value <= 0:
-            raise ValueError(
-                "gaussian_width must be greater than zero for Voigt profile."
-            )
+            raise ValueError("The gaussian_width of a Voigt must be greater than zero.")
         if self.lorentzian_width.value <= 0:
             raise ValueError(
-                "lorentzian_width must be greater than zero for Voigt profile."
+                "The lorentzian_width of a Voigt must be greater than zero."
             )
         if self.area.value < 0:
             warnings.warn(
@@ -768,11 +766,11 @@ def __init__(
     def evaluate(self, x: Union[Numeric, sc.Variable]) -> Union[float, np.ndarray]:
         if self.width.value <= 0:
             raise ValueError(
-                "Width of a Damped Harmonic Oscillator must be greater than zero."
+                "The width of a DampedHarmonicOscillator must be greater than zero."
             )
         if self.area.value < 0:
             warnings.warn(
-                "The area of the Damped Harmonic Oscillator with name {} is negative, which may not be physically meaningful.".format(
+                "The area of the DampedHarmonicOscillator with name {} is negative, which may not be physically meaningful.".format(
                     self.name
                 )
             )

tests/unit_tests/sample/test_components.py

@@ -178,10 +178,28 @@ def test_negative_width_raises(self):
         ):
             Gaussian(name="TestGaussian", area=2.0, center=0.5, width=-0.6, unit="meV")
 
+    def test_negative_width_raises_in_evaluate(self):
+        test_gaussian = Gaussian(
+            name="TestGaussian", area=2.0, center=0.5, width=0.6, unit="meV"
+        )
+        test_gaussian.width.value = -0.6
+        with pytest.raises(
+            ValueError, match="The width of a Gaussian must be greater than zero."
+        ):
+            test_gaussian.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_negative_area_warns(self):
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             Gaussian(name="TestGaussian", area=-2.0, center=0.5, width=0.6, unit="meV")
 
+    def test_negative_area_warns_in_evaluate(self):
+        test_gaussian = Gaussian(
+            name="TestGaussian", area=2.0, center=0.5, width=0.6, unit="meV"
+        )
+        test_gaussian.area.value = -2.0
+        with pytest.warns(UserWarning, match="may not be physically meaningful"):
+            test_gaussian.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_evaluate(self, gaussian: Gaussian):
         x = np.array([0.0, 0.5, 1.0])
         expected = gaussian.evaluate(x)
@@ -249,6 +267,14 @@ def test_area_matches_parameter(self, gaussian: Gaussian):
         # THEN EXPECT
         assert np.isclose(numerical_area, gaussian.area.value, rtol=1e-3)
 
+    def test_convert_unit(self, gaussian: Gaussian):
+        gaussian.convert_unit("microeV")
+
+        assert gaussian.unit == "microeV"
+        assert gaussian.area.value == 2 * 1e3
+        assert gaussian.center.value == 0.5 * 1e3
+        assert gaussian.width.value == 0.6 * 1e3
+
     def test_copy(self, gaussian: Gaussian):
         gaussian_copy = gaussian.copy()
         assert gaussian_copy is not gaussian
@@ -318,12 +344,30 @@ def test_negative_width_raises(self):
                 name="TestLorentzian", area=2.0, center=0.5, width=-0.6, unit="meV"
             )
 
+    def test_negative_width_raises_in_evaluate(self):
+        test_lorentzian = Lorentzian(
+            name="TestLorentzian", area=2.0, center=0.5, width=0.6, unit="meV"
+        )
+        test_lorentzian.width.value = -0.6
+        with pytest.raises(
+            ValueError, match="The width of a Lorentzian must be greater than zero."
+        ):
+            test_lorentzian.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_negative_area_warns(self):
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             Lorentzian(
                 name="TestLorentzian", area=-2.0, center=0.5, width=0.6, unit="meV"
             )
 
+    def test_negative_area_warns_in_evaluate(self):
+        test_lorentzian = Lorentzian(
+            name="TestLorentzian", area=2.0, center=0.5, width=0.6, unit="meV"
+        )
+        test_lorentzian.area.value = -2.0
+        with pytest.warns(UserWarning, match="may not be physically meaningful"):
+            test_lorentzian.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_evaluate(self, lorentzian: Lorentzian):
         x = np.array([0.0, 0.5, 1.0])
         expected = lorentzian.evaluate(x)
@@ -387,6 +431,14 @@ def test_area_matches_parameter(self, lorentzian: Lorentzian):
         # THEN EXPECT
         assert numerical_area == pytest.approx(lorentzian.area.value, rel=2e-3)
 
+    def test_convert_unit(self, lorentzian: Lorentzian):
+        lorentzian.convert_unit("microeV")
+
+        assert lorentzian.unit == "microeV"
+        assert lorentzian.area.value == 2 * 1e3
+        assert lorentzian.center.value == 0.5 * 1e3
+        assert lorentzian.width.value == 0.6 * 1e3
+
     def test_copy(self, lorentzian: Lorentzian):
         lorentzian_copy = lorentzian.copy()
         assert lorentzian_copy is not lorentzian
@@ -501,6 +553,21 @@ def test_negative_gaussian_width_raises(self):
                 unit="meV",
             )
 
+    def test_negative_gaussian_width_raises_in_evaluate(self):
+        test_voigt = Voigt(
+            name="TestVoigt",
+            area=2.0,
+            center=0.5,
+            gaussian_width=0.6,
+            lorentzian_width=0.7,
+            unit="meV",
+        )
+        test_voigt.gaussian_width.value = -0.6
+        with pytest.raises(
+            ValueError, match="The gaussian_width of a Voigt must be greater than."
+        ):
+            test_voigt.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_negative_lorentzian_width_raises(self):
         with pytest.raises(
             ValueError,
@@ -515,6 +582,22 @@ def test_negative_lorentzian_width_raises(self):
                 unit="meV",
             )
 
+    def test_negative_lorentzian_width_raises_in_evaluate(self):
+        test_voigt = Voigt(
+            name="TestVoigt",
+            area=2.0,
+            center=0.5,
+            gaussian_width=0.6,
+            lorentzian_width=0.7,
+            unit="meV",
+        )
+        test_voigt.lorentzian_width.value = -0.7
+        with pytest.raises(
+            ValueError,
+            match="The lorentzian_width of a Voigt must be greater than zero.",
+        ):
+            test_voigt.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_negative_area_warns(self):
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             Voigt(
@@ -526,6 +609,19 @@ def test_negative_area_warns(self):
                 unit="meV",
             )
 
+    def test_negative_area_warns_in_evaluate(self):
+        test_voigt = Voigt(
+            name="TestVoigt",
+            area=2.0,
+            center=0.5,
+            gaussian_width=0.6,
+            lorentzian_width=0.7,
+            unit="meV",
+        )
+        test_voigt.area.value = -2.0
+        with pytest.warns(UserWarning, match="may not be physically meaningful"):
+            test_voigt.evaluate(np.array([0.0, 0.5, 1.0]))
+
     def test_evaluate(self, voigt: Voigt):
         x = np.array([0.0, 0.5, 1.0])
         expected = voigt.evaluate(x)
@@ -580,31 +676,14 @@ def test_input_as_parameter(self):
         assert test_voigt.gaussian_width == param_gaussian_width
         assert test_voigt.lorentzian_width == param_lorentzian_width
 
-    def test_negative_width_raises(self):
-        with pytest.raises(
-            ValueError, match="The gaussian_width of a Voigt must be greater than zero"
-        ):
-            Voigt(
-                name="TestVoigt",
-                area=2.0,
-                center=0.5,
-                gaussian_width=-0.6,
-                lorentzian_width=0.7,
-                unit="meV",
-            )
+    def test_convert_unit(self, voigt: Voigt):
+        voigt.convert_unit("microeV")
 
-        with pytest.raises(
-            ValueError,
-            match="The lorentzian_width of a Voigt must be greater than zero",
-        ):
-            Voigt(
-                name="TestVoigt",
-                area=2.0,
-                center=0.5,
-                gaussian_width=0.6,
-                lorentzian_width=-0.7,
-                unit="meV",
-            )
+        assert voigt.unit == "microeV"
+        assert voigt.area.value == 2 * 1e3
+        assert voigt.center.value == 0.5 * 1e3
+        assert voigt.gaussian_width.value == 0.6 * 1e3
+        assert voigt.lorentzian_width.value == 0.7 * 1e3
 
     def test_get_parameters(self, voigt: Voigt):
         params = voigt.get_parameters()
@@ -730,6 +809,13 @@ def test_get_parameters(self, delta_function: DeltaFunction):
         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
@@ -816,6 +902,21 @@ 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(
@@ -826,6 +927,18 @@ 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)
@@ -902,6 +1015,14 @@ def test_area_matches_parameter(self, dho: DampedHarmonicOscillator):
         # 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
@@ -956,7 +1077,7 @@ def test_input_type_validation_raises(self):
         ):
             Polynomial(name="TestPolynomial", coefficients=[])
 
-    def test_negative_value_warns(self):
+    def test_negative_value_warns_in_evaluate(self):
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             test_polynomial = Polynomial(name="TestPolynomial", coefficients=[-1.0])
             test_polynomial.evaluate(np.array([0.0, 1.0, 2.0]))
@@ -967,6 +1088,24 @@ def test_evaluate(self, polynomial: Polynomial):
         expected_result = 1.0 - 2.0 * x + 3.0 * x**2
         np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
 
+    def test_evaluate_scipp_array(self, polynomial: Polynomial):
+        x = sc.array(dims=["x"], values=[0.0, 1.0, 2.0], unit="meV")
+        expected = polynomial.evaluate(x)
+        expected_result = 1.0 - 2.0 * x.values + 3.0 * x.values**2
+        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+
+    def test_evaluate_with_different_unit_error(self, polynomial: Polynomial):
+        x = sc.array(dims=["x"], values=[0.0, 1.0, 2.0], unit="microeV")
+
+        with pytest.raises(
+            ValueError,
+            match="Change the unit of the Polynomial and try again",
+        ):
+            polynomial.evaluate(x)
+
+    def test_degree(self, polynomial: Polynomial):
+        assert polynomial.degree() == 2
+
     def test_get_parameters(self, polynomial: Polynomial):
         params = polynomial.get_parameters()
         assert len(params) == 3