add feature so that user can run scale_to without xvalue

Author: yucongalicechen

src/diffpy/utils/diffraction_objects.py

@@ -402,14 +402,16 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
 
         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.
+        If none of `q`, `tth`, or `d` are provided,
+        the scaling will be based on the maximal x-array value from both objects.
+        If multiple values of `q`, `tth`, or `d` are provided, an error will be raised.
 
         Parameters
         ----------
         target_diff_object: DiffractionObject
             the diffraction object you want to scale the current one onto
 
-        q, tth, d : float, optional, must specify exactly one of them
+        q, tth, d : float, optional, default is q with the maximal x-array value of the current object
             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.
 
@@ -422,11 +424,16 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=0):
         """
         scaled = self.copy()
         count = sum([q is not None, tth is not None, d is not None])
-        if count != 1:
+        if count > 1:
             raise ValueError(
-                "You must specify exactly one of 'q', 'tth', or 'd'. Please rerun specifying only one."
+                "You must specify none or exactly one of 'q', 'tth', or 'd'. "
+                "Please provide either none or one value."
             )
 
+        if count == 0:
+            scaled._all_arrays[:, 0] *= max(target_diff_object.on_q()[1]) / max(self.on_q()[1])
+            return scaled
+
         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)

tests/test_diffraction_objects.py

@@ -284,23 +284,7 @@ def test_init_invalid_xtype():
             },
             {"xtype": "tth", "yarray": np.array([4.1, 5.1, 6.1, 7.1, 8.1, 9.1])},
         ),
-    ],
-)
-def test_scale_to(org_do_args, target_do_args, scale_inputs, expected):
-    original_do = DiffractionObject(**org_do_args)
-    target_do = DiffractionObject(**target_do_args)
-    scaled_do = original_do.scale_to(
-        target_do, q=scale_inputs["q"], tth=scale_inputs["tth"], d=scale_inputs["d"], offset=scale_inputs["offset"]
-    )
-    # Check the intensity data is the same as expected
-    assert np.allclose(scaled_do.on_xtype(expected["xtype"])[1], expected["yarray"])
-
-
-@pytest.mark.parametrize(
-    "org_do_args, target_do_args, scale_inputs",
-    [
-        # Test expected errors produced from scale_to() with invalid inputs
-        (  # C1: none of q, tth, d, provided, expect ValueError
+        (  # C5: none of q, tth, d, provided, expect to scale on the maximal x-arrays
             {
                 "xarray": np.array([0.1, 0.2, 0.3]),
                 "yarray": np.array([1, 2, 3]),
@@ -319,8 +303,25 @@ def test_scale_to(org_do_args, target_do_args, scale_inputs, expected):
                 "d": None,
                 "offset": 0,
             },
+            {"xtype": "q", "yarray": np.array([10, 20, 30])},
         ),
-        (  # C2: tth and d both provided, expect ValueErrort
+    ],
+)
+def test_scale_to(org_do_args, target_do_args, scale_inputs, expected):
+    original_do = DiffractionObject(**org_do_args)
+    target_do = DiffractionObject(**target_do_args)
+    scaled_do = original_do.scale_to(
+        target_do, q=scale_inputs["q"], tth=scale_inputs["tth"], d=scale_inputs["d"], offset=scale_inputs["offset"]
+    )
+    # Check the intensity data is the same as expected
+    assert np.allclose(scaled_do.on_xtype(expected["xtype"])[1], expected["yarray"])
+
+
+@pytest.mark.parametrize(
+    "org_do_args, target_do_args, scale_inputs",
+    [
+        # Test expected errors produced from scale_to() with invalid inputs
+        (  # C2: tth and d both provided, expect ValueError
             {
                 "xarray": np.array([10, 25, 30.1, 40.2, 61, 120, 140]),
                 "yarray": np.array([10, 20, 30, 40, 50, 60, 100]),
@@ -346,7 +347,9 @@ def test_scale_to_bad(org_do_args, target_do_args, scale_inputs):
     original_do = DiffractionObject(**org_do_args)
     target_do = DiffractionObject(**target_do_args)
     with pytest.raises(
-        ValueError, match="You must specify exactly one of 'q', 'tth', or 'd'. Please rerun specifying only one."
+        ValueError,
+        match="You must specify none or exactly one of 'q', 'tth', or 'd'. "
+        "Please provide either none or one value.",
     ):
         original_do.scale_to(
             target_do,