Merge pull request #211 from yucongalicechen/scaleto

tests for scale_to

Author: sbillinge

news/scaleto.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* functionality to rescale diffraction objects, placing one on top of another at a specified point
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

src/diffpy/utils/diffraction_objects.py

@@ -401,40 +401,46 @@ def on_tth(self):
     def on_d(self):
         return [self.all_arrays[:, 3], self.all_arrays[:, 0]]
 
-    def scale_to(self, target_diff_object, xtype=None, xvalue=None):
+    def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
         """
-        Return a new diffraction object which is the current object but recaled in y to the target
+        returns a new diffraction object which is the current object but rescaled in y to the target
+
+        The y-value in the target at the closest specified x-value will be used as the factor to scale to.
+        The entire array is scaled by this factor so that one object places on top of the other at that point.
+        If multiple values of `q`, `tth`, or `d` are provided, or none are provided, an error will be raised.
 
         Parameters
         ----------
         target_diff_object: DiffractionObject
-          the diffraction object you want to scale the current one on to
-        xtype: string, optional.  Default is Q
-          the xtype, from {XQUANTITIES}, that you will specify a point from to scale to
-        xvalue: float. Default is the midpoint of the array
-          the y-value in the target at this x-value will be used as the factor to scale to.
-          The entire array is scaled be the factor that places on on top of the other at that point.
-          xvalue does not have to be in the x-array, the point closest to this point will be used for the scaling.
+            the diffraction object you want to scale the current one onto
+
+        q, tth, d : float, optional, must specify exactly one of them
+            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
 
         Returns
         -------
         the rescaled DiffractionObject as a new object
-
         """
-        scaled = deepcopy(self)
-        if xtype is None:
-            xtype = "q"
+        scaled = self.copy()
+        count = sum([q is not None, tth is not None, d is not None])
+        if count != 1:
+            raise ValueError(
+                "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"
         data = self.on_xtype(xtype)
         target = target_diff_object.on_xtype(xtype)
-        if xvalue is None:
-            xvalue = data[0][0] + (data[0][-1] - data[0][0]) / 2.0
-
-        xindex = (np.abs(data[0] - xvalue)).argmin()
-        ytarget = target[1][xindex]
-        yself = data[1][xindex]
-        scaled.on_tth[1] = data[1] * ytarget / yself
-        scaled.on_q[1] = data[1] * ytarget / yself
+
+        xvalue = q if xtype == "q" else tth if xtype == "tth" else d
+
+        xindex_data = (np.abs(data[0] - xvalue)).argmin()
+        xindex_target = (np.abs(target[0] - xvalue)).argmin()
+        scaled._all_arrays[:, 0] = data[1] * target[1][xindex_target] / data[1][xindex_data] + offset
         return scaled
 
     def on_xtype(self, xtype):

tests/test_diffraction_objects.py

@@ -182,6 +182,158 @@ def test_init_invalid_xtype():
         DiffractionObject(xtype="invalid_type")
 
 
+params_scale_to = [
+    # UC1: same x-array and y-array, check offset
+    (
+        {
+            "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
+    (
+        {
+            "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
+    (
+        {
+            "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
+    (
+        {
+            "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["xarray"], yarray=inputs["yarray"], xtype=inputs["xtype"], wavelength=inputs["wavelength"]
+    )
+    target_diff_object = DiffractionObject(
+        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["q"], tth=inputs["tth"], d=inputs["d"], offset=inputs["offset"]
+    )
+    # 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
+    (
+        {
+            "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
+    (
+        {
+            "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["xarray"], yarray=inputs["yarray"], xtype=inputs["xtype"], wavelength=inputs["wavelength"]
+    )
+    target_diff_object = DiffractionObject(
+        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["q"], tth=inputs["tth"], d=inputs["d"], offset=inputs["offset"]
+        )
+
+
 params_index = [
     # UC1: exact match
     (4 * np.pi, np.array([30.005, 60]), np.array([1, 2]), "tth", "tth", 30.005, [0]),