tests for scale_to

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

@@ -364,40 +364,41 @@ 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):
-        f"""
-        returns a new diffraction object which is the current object but recaled in y to the target
+    def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
+        """
+        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, the priority is `q` > `tth` > `d`.
+        If none are provided, the midpoint of the current object's `q`-array will be used.
 
         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, default is the midpoint of the current object's `q`-array
+            the xvalue (in `q`, `tth`, or `d` space) to align the current and target objects
+
+        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()
+        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)
 
-        data = self.on_xtype(xtype)
-        target = target_diff_object.on_xtype(xtype)
+        xvalue = q if xtype == "q" else tth if xtype == "tth" else d
         if xvalue is None:
-            xvalue = data[0][0] + (data[0][-1] - data[0][0]) / 2.0
+            xvalue = (data[0][0] + data[0][-1]) / 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
+        x_data, x_target = (np.abs(data[0] - xvalue)).argmin(), (np.abs(target[0] - xvalue)).argmin()
+        y_data, y_target = data[1][x_data], target[1][x_target]
+        scaled._all_arrays[:, 0] = data[1] * y_target / y_data + offset
         return scaled
 
     def on_xtype(self, xtype):

tests/test_diffraction_objects.py

@@ -223,6 +223,114 @@ def test_on_xtype_bad():
         test.on_xtype("invalid")
 
 
+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])],
+    ),
+    # 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])],
+    ),
+    # 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])],
+    ),
+    # 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])],
+    ),
+    # UC5: user specified multiple x-values, prioritize q > tth > 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,
+        ],
+        ["tth", 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])
+    target_diff_object = DiffractionObject(
+        xarray=inputs[4], yarray=inputs[5], xtype=inputs[6], wavelength=inputs[7]
+    )
+    scaled_diff_object = orig_diff_object.scale_to(
+        target_diff_object, q=inputs[8], tth=inputs[9], d=inputs[10], offset=inputs[11]
+    )
+    # Check the intensity data is same as expected
+    assert np.allclose(scaled_diff_object.on_xtype(expected[0])[1], expected[1])
+
+
 params_index = [
     # UC1: exact match
     ([4 * np.pi, np.array([30.005, 60]), np.array([1, 2]), "tth", "tth", 30.005], [0]),