Fix another divide by zero warning in transform

Author: bobleesj

tests/test_diffraction_objects.py

@@ -403,114 +403,101 @@ def test_dump(tmp_path, mocker):
     assert actual == expected
 
 
-test_init_valid_params = [
-    (  # instantiate just array attributes
-        {
-            "xarray": np.array([0.0, 90.0, 180.0]),
-            "yarray": np.array([1.0, 2.0, 3.0]),
-            "xtype": "tth",
-            "wavelength": 4.0 * np.pi,
-        },
-        {
-            "_all_arrays": np.array(
-                [
-                    [1.0, 0.0, 0.0, np.float64(np.inf)],
-                    [2.0, 1.0 / np.sqrt(2), 90.0, np.sqrt(2) * 2 * np.pi],
-                    [3.0, 1.0, 180.0, 1.0 * 2 * np.pi],
-                ]
-            ),
-            "metadata": {},
-            "_input_xtype": "tth",
-            "name": "",
-            "scat_quantity": "",
-            "qmin": np.float64(0.0),
-            "qmax": np.float64(1.0),
-            "tthmin": np.float64(0.0),
-            "tthmax": np.float64(180.0),
-            "dmin": np.float64(2 * np.pi),
-            "dmax": np.float64(np.inf),
-            "wavelength": 4.0 * np.pi,
-        },
-    ),
-    (  # instantiate just array attributes
-        {
-            "xarray": np.array([np.inf, 2 * np.sqrt(2) * np.pi, 2 * np.pi]),
-            "yarray": np.array([1.0, 2.0, 3.0]),
-            "xtype": "d",
-            "wavelength": 4.0 * np.pi,
-            "scat_quantity": "x-ray",
-        },
-        {
-            "_all_arrays": np.array(
-                [
-                    [1.0, 0.0, 0.0, np.float64(np.inf)],
-                    [2.0, 1.0 / np.sqrt(2), 90.0, np.sqrt(2) * 2 * np.pi],
-                    [3.0, 1.0, 180.0, 1.0 * 2 * np.pi],
-                ]
-            ),
-            "metadata": {},
-            "_input_xtype": "d",
-            "name": "",
-            "scat_quantity": "x-ray",
-            "qmin": np.float64(0.0),
-            "qmax": np.float64(1.0),
-            "tthmin": np.float64(0.0),
-            "tthmax": np.float64(180.0),
-            "dmin": np.float64(2 * np.pi),
-            "dmax": np.float64(np.inf),
-            "wavelength": 4.0 * np.pi,
-        },
-    ),
-]
-
-
 @pytest.mark.parametrize(
-    "init_args, expected_do_dict",
-    test_init_valid_params,
+    "do_init_args, expected_do_dict",
+    [
+        (  # instantiate just array attributes
+            {
+                "xarray": np.array([0.0, 90.0, 180.0]),
+                "yarray": np.array([1.0, 2.0, 3.0]),
+                "xtype": "tth",
+                "wavelength": 4.0 * np.pi,
+            },
+            {
+                "_all_arrays": np.array(
+                    [
+                        [1.0, 0.0, 0.0, np.float64(np.inf)],
+                        [2.0, 1.0 / np.sqrt(2), 90.0, np.sqrt(2) * 2 * np.pi],
+                        [3.0, 1.0, 180.0, 1.0 * 2 * np.pi],
+                    ]
+                ),
+                "metadata": {},
+                "_input_xtype": "tth",
+                "name": "",
+                "scat_quantity": "",
+                "qmin": np.float64(0.0),
+                "qmax": np.float64(1.0),
+                "tthmin": np.float64(0.0),
+                "tthmax": np.float64(180.0),
+                "dmin": np.float64(2 * np.pi),
+                "dmax": np.float64(np.inf),
+                "wavelength": 4.0 * np.pi,
+            },
+        ),
+        (  # instantiate just array attributes
+            {
+                "xarray": np.array([np.inf, 2 * np.sqrt(2) * np.pi, 2 * np.pi]),
+                "yarray": np.array([1.0, 2.0, 3.0]),
+                "xtype": "d",
+                "wavelength": 4.0 * np.pi,
+                "scat_quantity": "x-ray",
+            },
+            {
+                "_all_arrays": np.array(
+                    [
+                        [1.0, 0.0, 0.0, np.float64(np.inf)],
+                        [2.0, 1.0 / np.sqrt(2), 90.0, np.sqrt(2) * 2 * np.pi],
+                        [3.0, 1.0, 180.0, 1.0 * 2 * np.pi],
+                    ]
+                ),
+                "metadata": {},
+                "_input_xtype": "d",
+                "name": "",
+                "scat_quantity": "x-ray",
+                "qmin": np.float64(0.0),
+                "qmax": np.float64(1.0),
+                "tthmin": np.float64(0.0),
+                "tthmax": np.float64(180.0),
+                "dmin": np.float64(2 * np.pi),
+                "dmax": np.float64(np.inf),
+                "wavelength": 4.0 * np.pi,
+            },
+        ),
+    ],
 )
-def test_init_valid(init_args, expected_do_dict):
-    actual_do_dict = DiffractionObject(**init_args).__dict__
+def test_init_valid(do_init_args, expected_do_dict):
+    actual_do_dict = DiffractionObject(**do_init_args).__dict__
     diff = DeepDiff(
         actual_do_dict, expected_do_dict, ignore_order=True, significant_digits=13, exclude_paths="root['_id']"
     )
     assert diff == {}
 
 
-test_init_invalid_params = [
-    (  # UC1: no arguments provided
-        {},
-        "missing 3 required positional arguments: 'xarray', 'yarray', and 'xtype'",
-    ),
-    (  # UC2: only xarray and yarray provided
-        {"xarray": np.array([0.0, 90.0]), "yarray": np.array([0.0, 90.0])},
-        "missing 1 required positional argument: 'xtype'",
-    ),
-]
-
-
-@pytest.mark.parametrize("init_args, expected_error_msg", test_init_invalid_params)
+@pytest.mark.parametrize(
+    "do_init_args, expected_error_msg",
+    [
+        (  # Case 1: no arguments provided
+            {},
+            "missing 3 required positional arguments: 'xarray', 'yarray', and 'xtype'",
+        ),
+        (  # Case 2: only xarray and yarray provided
+            {"xarray": np.array([0.0, 90.0]), "yarray": np.array([0.0, 90.0])},
+            "missing 1 required positional argument: 'xtype'",
+        ),
+    ],
+)
 def test_init_invalid_args(
-    init_args,
+    do_init_args,
     expected_error_msg,
 ):
     with pytest.raises(TypeError, match=expected_error_msg):
-        DiffractionObject(**init_args)
+        DiffractionObject(**do_init_args)
 
 
-def test_all_array_getter():
-    actual_do = DiffractionObject(
-        xarray=np.array([0.0, 90.0, 180.0]),
-        yarray=np.array([1.0, 2.0, 3.0]),
-        xtype="tth",
-        wavelength=4.0 * np.pi,
-    )
-    expected_all_arrays = np.array(
-        [
-            [1.0, 0.0, 0.0, np.float64(np.inf)],
-            [2.0, 1.0 / np.sqrt(2), 90.0, np.sqrt(2) * 2 * np.pi],
-            [3.0, 1.0, 180.0, 1.0 * 2 * np.pi],
-        ]
-    )
+def test_all_array_getter(do_minimal_tth):
+    actual_do = do_minimal_tth
+    print(actual_do.all_arrays)
+    expected_all_arrays = [[1, 0.51763809, 30, 12.13818192], [2, 1, 60, 6.28318531]]
     assert np.allclose(actual_do.all_arrays, expected_all_arrays)
 
 
@@ -575,14 +562,8 @@ def test_input_xtype_setter_error(do_minimal):
         do.input_xtype = "q"
 
 
-def test_copy_object():
-    do = DiffractionObject(
-        name="test",
-        wavelength=4.0 * np.pi,
-        xarray=np.array([0.0, 90.0, 180.0]),
-        yarray=np.array([1.0, 2.0, 3.0]),
-        xtype="tth",
-    )
+def test_copy_object(do_minimal):
+    do = do_minimal
     do_copy = do.copy()
     assert do == do_copy
     assert id(do) != id(do_copy)

tests/test_transforms.py

@@ -146,43 +146,43 @@ def test_q_to_d(q, expected_d, warning_expected):
 
 
 @pytest.mark.parametrize(
-    "d, expected_q",
+    "d, expected_q, zero_divide_error_expected",
     [
         # UC1: User specified empty d values
-        (np.array([]), np.array([])),
+        (np.array([]), np.array([]), False),
         # UC2: User specified valid d values
         (
             np.array([5 * np.pi, 4 * np.pi, 3 * np.pi, 2 * np.pi, np.pi, 0]),
             np.array([0.4, 0.5, 0.66667, 1, 2, np.inf]),
+            True,
         ),
     ],
 )
-def test_d_to_q(d, expected_q):
-    actual_q = d_to_q(d)
+def test_d_to_q(d, expected_q, zero_divide_error_expected):
+    if zero_divide_error_expected:
+        with pytest.warns(RuntimeWarning, match="divide by zero encountered in divide"):
+            actual_q = d_to_q(d)
+    else:
+        actual_q = d_to_q(d)
     assert np.allclose(actual_q, expected_q)
 
 
 @pytest.mark.parametrize(
     "wavelength, tth, expected_d, divide_by_zero_warning_expected",
-    [   
+    [
         # Test conversion of q to d with valid values
         # Case 1: empty tth values, no, expect empty d values
         (None, np.array([]), np.array([]), False),
         # Case 2: empty tth values, wavelength provided, expect empty d values
         (4 * np.pi, np.array([]), np.array([]), False),
         # Case 3: User specified valid tth values between 0-180 degrees (without wavelength)
-        (
-            None,
-            np.array([0, 30, 60, 90, 120, 180]),
-            np.array([0, 1, 2, 3, 4, 5]),
-            False
-        ),
+        (None, np.array([0, 30, 60, 90, 120, 180]), np.array([0, 1, 2, 3, 4, 5]), False),
         # Case 4: User specified valid tth values between 0-180 degrees (with wavelength)
         (
             4 * np.pi,
             np.array([0, 30.0, 60.0, 90.0, 120.0, 180.0]),
             np.array([np.inf, 24.27636, 12.56637, 8.88577, 7.25520, 6.28319]),
-            True
+            True,
         ),
     ],
 )