make tests more readable

Author: yucongalicechen

src/diffpy/utils/diffraction_objects.py

@@ -405,7 +405,8 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
             the diffraction object you want to scale the current one onto
 
         q, tth, d : float, optional, must specify exactly one of them
-            the xvalue (in `q`, `tth`, or `d` space) to align the current and target objects
+            The value of the x-array where you want the curves to line up vertically.
+            Specify a value on one of the allowed grids, q, tth, or d), e.g., q=10.
 
         offset : float, optional, default is 0
             an offset to add to the scaled y-values
@@ -421,8 +422,9 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
                 "You must specify exactly one of 'q', 'tth', or 'd'. Please rerun specifying only one."
             )
 
-        xtype = "q" if q is not None else "tth" if tth is not None else "d" if d is not None else "q"
-        data, target = self.on_xtype(xtype), target_diff_object.on_xtype(xtype)
+        xtype = "q" if q is not None else "tth" if tth is not None else "d"
+        data = self.on_xtype(xtype)
+        target = target_diff_object.on_xtype(xtype)
 
         xvalue = q if xtype == "q" else tth if xtype == "tth" else d
 

tests/test_diffraction_objects.py

@@ -183,137 +183,153 @@ def test_init_invalid_xtype():
 params_scale_to = [
     # UC1: same x-array and y-array, check offset
     (
-        [
-            np.array([10, 15, 25, 30, 60, 140]),
-            np.array([2, 3, 4, 5, 6, 7]),
-            "tth",
-            2 * np.pi,
-            np.array([10, 15, 25, 30, 60, 140]),
-            np.array([2, 3, 4, 5, 6, 7]),
-            "tth",
-            2 * np.pi,
-            None,
-            60,
-            None,
-            2.1,
-        ],
-        ["tth", np.array([4.1, 5.1, 6.1, 7.1, 8.1, 9.1])],
+        {
+            "xarray": np.array([10, 15, 25, 30, 60, 140]),
+            "yarray": np.array([2, 3, 4, 5, 6, 7]),
+            "xtype": "tth",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([10, 15, 25, 30, 60, 140]),
+            "target_yarray": np.array([2, 3, 4, 5, 6, 7]),
+            "target_xtype": "tth",
+            "target_wavelength": 2 * np.pi,
+            "q": None,
+            "tth": 60,
+            "d": None,
+            "offset": 2.1,
+        },
+        {"xtype": "tth", "yarray": np.array([4.1, 5.1, 6.1, 7.1, 8.1, 9.1])},
     ),
     # UC2: same length x-arrays with exact x-value match
     (
-        [
-            np.array([10, 15, 25, 30, 60, 140]),
-            np.array([10, 20, 25, 30, 60, 100]),
-            "tth",
-            2 * np.pi,
-            np.array([10, 20, 25, 30, 60, 140]),
-            np.array([2, 3, 4, 5, 6, 7]),
-            "tth",
-            2 * np.pi,
-            None,
-            60,
-            None,
-            0,
-        ],
-        ["tth", np.array([1, 2, 2.5, 3, 6, 10])],
+        {
+            "xarray": np.array([10, 15, 25, 30, 60, 140]),
+            "yarray": np.array([10, 20, 25, 30, 60, 100]),
+            "xtype": "tth",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([10, 20, 25, 30, 60, 140]),
+            "target_yarray": np.array([2, 3, 4, 5, 6, 7]),
+            "target_xtype": "tth",
+            "target_wavelength": 2 * np.pi,
+            "q": None,
+            "tth": 60,
+            "d": None,
+            "offset": 0,
+        },
+        {"xtype": "tth", "yarray": np.array([1, 2, 2.5, 3, 6, 10])},
     ),
     # UC3: same length x-arrays with approximate x-value match
     (
-        [
-            np.array([0.12, 0.24, 0.31, 0.4]),
-            np.array([10, 20, 40, 60]),
-            "q",
-            2 * np.pi,
-            np.array([0.14, 0.24, 0.31, 0.4]),
-            np.array([1, 3, 4, 5]),
-            "q",
-            2 * np.pi,
-            0.1,
-            None,
-            None,
-            0,
-        ],
-        ["q", np.array([1, 2, 4, 6])],
+        {
+            "xarray": np.array([0.12, 0.24, 0.31, 0.4]),
+            "yarray": np.array([10, 20, 40, 60]),
+            "xtype": "q",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([0.14, 0.24, 0.31, 0.4]),
+            "target_yarray": np.array([1, 3, 4, 5]),
+            "target_xtype": "q",
+            "target_wavelength": 2 * np.pi,
+            "q": 0.1,
+            "tth": None,
+            "d": None,
+            "offset": 0,
+        },
+        {"xtype": "q", "yarray": np.array([1, 2, 4, 6])},
     ),
     # UC4: different x-array lengths with approximate x-value match
     (
-        [
-            np.array([10, 25, 30.1, 40.2, 61, 120, 140]),
-            np.array([10, 20, 30, 40, 50, 60, 100]),
-            "tth",
-            2 * np.pi,
-            np.array([20, 25.5, 32, 45, 50, 62, 100, 125, 140]),
-            np.array([1.1, 2, 3, 3.5, 4, 5, 10, 12, 13]),
-            "tth",
-            2 * np.pi,
-            None,
-            60,
-            None,
-            0,
-        ],
-        # scaling factor is calculated at index = 5 for self and index = 6 for target
-        ["tth", np.array([1, 2, 3, 4, 5, 6, 10])],
+        {
+            "xarray": np.array([10, 25, 30.1, 40.2, 61, 120, 140]),
+            "yarray": np.array([10, 20, 30, 40, 50, 60, 100]),
+            "xtype": "tth",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([20, 25.5, 32, 45, 50, 62, 100, 125, 140]),
+            "target_yarray": np.array([1.1, 2, 3, 3.5, 4, 5, 10, 12, 13]),
+            "target_xtype": "tth",
+            "target_wavelength": 2 * np.pi,
+            "q": None,
+            "tth": 60,
+            "d": None,
+            "offset": 0,
+        },
+        # scaling factor is calculated at index = 4 (tth=61) for self and index = 5 for target (tth=62)
+        {"xtype": "tth", "yarray": np.array([1, 2, 3, 4, 5, 6, 10])},
     ),
 ]
 
 
 @pytest.mark.parametrize("inputs, expected", params_scale_to)
 def test_scale_to(inputs, expected):
-    orig_diff_object = DiffractionObject(xarray=inputs[0], yarray=inputs[1], xtype=inputs[2], wavelength=inputs[3])
+    orig_diff_object = DiffractionObject(
+        xarray=inputs["xarray"], yarray=inputs["yarray"], xtype=inputs["xtype"], wavelength=inputs["wavelength"]
+    )
     target_diff_object = DiffractionObject(
-        xarray=inputs[4], yarray=inputs[5], xtype=inputs[6], wavelength=inputs[7]
+        xarray=inputs["target_xarray"],
+        yarray=inputs["target_yarray"],
+        xtype=inputs["target_xtype"],
+        wavelength=inputs["target_wavelength"],
     )
     scaled_diff_object = orig_diff_object.scale_to(
-        target_diff_object, q=inputs[8], tth=inputs[9], d=inputs[10], offset=inputs[11]
+        target_diff_object, q=inputs["q"], tth=inputs["tth"], d=inputs["d"], offset=inputs["offset"]
     )
-    # Check the intensity data is same as expected
-    assert np.allclose(scaled_diff_object.on_xtype(expected[0])[1], expected[1])
+    # Check the intensity data is the same as expected
+    assert np.allclose(scaled_diff_object.on_xtype(expected["xtype"])[1], expected["yarray"])
 
 
 params_scale_to_bad = [
     # UC1: user did not specify anything
     (
-        np.array([0.1, 0.2, 0.3]),
-        np.array([1, 2, 3]),
-        "q",
-        2 * np.pi,
-        np.array([0.05, 0.1, 0.2, 0.3]),
-        np.array([5, 10, 20, 30]),
-        "q",
-        2 * np.pi,
-        None,
-        None,
-        None,
-        0,
+        {
+            "xarray": np.array([0.1, 0.2, 0.3]),
+            "yarray": np.array([1, 2, 3]),
+            "xtype": "q",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([0.05, 0.1, 0.2, 0.3]),
+            "target_yarray": np.array([5, 10, 20, 30]),
+            "target_xtype": "q",
+            "target_wavelength": 2 * np.pi,
+            "q": None,
+            "tth": None,
+            "d": None,
+            "offset": 0,
+        }
     ),
     # UC2: user specified more than one of q, tth, and d
     (
-        np.array([10, 25, 30.1, 40.2, 61, 120, 140]),
-        np.array([10, 20, 30, 40, 50, 60, 100]),
-        "tth",
-        2 * np.pi,
-        np.array([20, 25.5, 32, 45, 50, 62, 100, 125, 140]),
-        np.array([1.1, 2, 3, 3.5, 4, 5, 10, 12, 13]),
-        "tth",
-        2 * np.pi,
-        None,
-        60,
-        10,
-        0,
+        {
+            "xarray": np.array([10, 25, 30.1, 40.2, 61, 120, 140]),
+            "yarray": np.array([10, 20, 30, 40, 50, 60, 100]),
+            "xtype": "tth",
+            "wavelength": 2 * np.pi,
+            "target_xarray": np.array([20, 25.5, 32, 45, 50, 62, 100, 125, 140]),
+            "target_yarray": np.array([1.1, 2, 3, 3.5, 4, 5, 10, 12, 13]),
+            "target_xtype": "tth",
+            "target_wavelength": 2 * np.pi,
+            "q": None,
+            "tth": 60,
+            "d": 10,
+            "offset": 0,
+        }
     ),
 ]
 
 
 @pytest.mark.parametrize("inputs", params_scale_to_bad)
 def test_scale_to_bad(inputs):
-    orig_diff_object = DiffractionObject(xarray=inputs[0], yarray=inputs[1], xtype=inputs[2], wavelength=inputs[3])
+    orig_diff_object = DiffractionObject(
+        xarray=inputs["xarray"], yarray=inputs["yarray"], xtype=inputs["xtype"], wavelength=inputs["wavelength"]
+    )
     target_diff_object = DiffractionObject(
-        xarray=inputs[4], yarray=inputs[5], xtype=inputs[6], wavelength=inputs[7]
+        xarray=inputs["target_xarray"],
+        yarray=inputs["target_yarray"],
+        xtype=inputs["target_xtype"],
+        wavelength=inputs["target_wavelength"],
     )
     with pytest.raises(
         ValueError, match="You must specify exactly one of 'q', 'tth', or 'd'. Please rerun specifying only one."
     ):
-        orig_diff_object.scale_to(target_diff_object, q=inputs[8], tth=inputs[9], d=inputs[10], offset=inputs[11])
+        orig_diff_object.scale_to(
+            target_diff_object, q=inputs["q"], tth=inputs["tth"], d=inputs["d"], offset=inputs["offset"]
+        )
 
 
 params_index = [