merge from main

Author: yucongalicechen

news/array_index.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* function to return the index of the closest value to the specified value in an array.
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

news/d-q.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* functions to convert between d and q
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

src/diffpy/utils/diffraction_objects.py

@@ -259,15 +259,29 @@ def _set_array_from_range(self, begin, end, step_size=None, n_steps=None):
             array = np.linspace(begin, end, n_steps)
         return array
 
-    def get_angle_index(self, angle):
-        count = 0
-        for i, target in enumerate(self.angles):
-            if angle == target:
-                return i
-            else:
-                count += 1
-        if count >= len(self.angles):
-            raise IndexError(f"WARNING: no angle {angle} found in angles list")
+    def get_array_index(self, value, xtype=None):
+        """
+        returns the index of the closest value in the array associated with the specified xtype
+
+        Parameters
+        ----------
+        xtype str
+            the xtype used to access the array
+        value float
+            the target value to search for
+
+        Returns
+        -------
+        the index of the value in the array
+        """
+
+        if xtype is None:
+            xtype = self.input_xtype
+        array = self.on_xtype(xtype)[0]
+        if len(array) == 0:
+            raise ValueError(f"The '{xtype}' array is empty. Please ensure it is initialized.")
+        i = (np.abs(array - value)).argmin()
+        return i
 
     def _set_xarrays(self, xarray, xtype):
         self._all_arrays = np.empty(shape=(len(xarray), 4))

src/diffpy/utils/transforms.py

@@ -16,7 +16,9 @@
     "The supplied input array and wavelength will result in an impossible two-theta. "
     "Please check these values and re-instantiate the DiffractionObject with correct values."
 )
-inf_output_wmsg = "WARNING: The largest output is infinite and cannot be plotted."
+inf_output_wmsg = (
+    "INFO: The largest output value in the array is infinite. This is allowed, but it will not be plotted."
+)
 
 
 def _validate_inputs(q, wavelength):
@@ -59,7 +61,6 @@ def q_to_tth(q, wavelength):
     -------
     tth : 1D array
         The array of :math:`2\theta` values in degrees numpy.array([tths]).
-        This is the correct format for loading into diffpy.utils.DiffractionOject.on_tth
     """
     _validate_inputs(q, wavelength)
     q.astype(float)
@@ -93,21 +94,18 @@ def tth_to_q(tth, wavelength):
 
     Parameters
     ----------
-    tth : 2D array
-        The array of :math:`2\theta` values and :math: 'i' intensity values, np.array([[tths], [is]]).
-        This is the same format as, and so can accept, diffpy.utils.DiffractionOject.on_tth
+    tth : 1D array
+        The array of :math:`2\theta` values np.array([tths]).
         The units of tth are expected in degrees.
 
     wavelength : float
         Wavelength of the incoming x-rays/neutrons/electrons
 
     Returns
     -------
-    on_q : 2D array
-        The array of :math:`q` values and :math: 'i' intensity values unchanged,
-        np.array([[qs], [is]]).
+    q : 1D array
+        The array of :math:`q` values np.array([qs]).
         The units for the q-values are the inverse of the units of the provided wavelength.
-        This is the correct format for loading into diffpy.utils.DiffractionOject.on_q
     """
     tth.astype(float)
     if np.any(np.deg2rad(tth) > np.pi):
@@ -117,13 +115,30 @@ def tth_to_q(tth, wavelength):
         pre_factor = (4.0 * np.pi) / wavelength
         q = pre_factor * np.sin(np.deg2rad(tth / 2))
     else:  # return intensities vs. an x-array that is just the index
+        warnings.warn(wavelength_warning_emsg, UserWarning)
         for i, _ in enumerate(q):
             q[i] = i
     return q
 
 
-def q_to_d(qarray):
-    return 2.0 * np.pi / copy(qarray)
+def q_to_d(q):
+    r"""
+    Helper function to convert q to d on independent variable axis, using :math:`d = \frac{2 \pi}{q}`.
+
+    Parameters
+    ----------
+    q : 1D array
+        The array of :math:`q` values np.array([qs]).
+        The units of q must be reciprocal of the units of wavelength.
+
+    Returns
+    -------
+    d : 1D array
+        The array of :math:`d` values np.array([ds]).
+    """
+    if 0 in q:
+        print(inf_output_wmsg)
+    return 2.0 * np.pi / copy(q)
 
 
 def tth_to_d(tth, wavelength):
@@ -160,8 +175,24 @@ def tth_to_d(tth, wavelength):
     return 2.0 * np.pi / copy(q)
 
 
-def d_to_q(darray):
-    return 2.0 * np.pi / copy(darray)
+def d_to_q(d):
+    r"""
+    Helper function to convert q to d using :math:`d = \frac{2 \pi}{q}`.
+
+    Parameters
+    ----------
+    d : 1D array
+        The array of :math:`d` values np.array([ds]).
+
+    Returns
+    -------
+    q : 1D array
+        The array of :math:`q` values np.array([qs]).
+        The units of q must be reciprocal of the units of wavelength.
+    """
+    if 0 in d:
+        warnings.warn(inf_output_wmsg)
+    return 2.0 * np.pi / copy(d)
 
 
 def d_to_tth(d, wavelength):

tests/test_diffraction_objects.py

@@ -1,3 +1,4 @@
+import re
 from pathlib import Path
 
 import numpy as np
@@ -212,6 +213,31 @@ def _test_valid_diffraction_objects(actual_diffraction_object, function, expecte
     return np.allclose(actual_array, expected_array)
 
 
+params_index = [
+    # UC1: exact match
+    ([4 * np.pi, np.array([30.005, 60]), np.array([1, 2]), "tth", "tth", 30.005], [0]),
+    # UC2: target value lies in the array, returns the (first) closest index
+    ([4 * np.pi, np.array([30, 60]), np.array([1, 2]), "tth", "tth", 45], [0]),
+    ([4 * np.pi, np.array([30, 60]), np.array([1, 2]), "tth", "q", 0.25], [0]),
+    # UC3: target value out of the range, returns the closest index
+    ([4 * np.pi, np.array([0.25, 0.5, 0.71]), np.array([1, 2, 3]), "q", "q", 0.1], [0]),
+    ([4 * np.pi, np.array([30, 60]), np.array([1, 2]), "tth", "tth", 63], [1]),
+]
+
+
+@pytest.mark.parametrize("inputs, expected", params_index)
+def test_get_array_index(inputs, expected):
+    test = DiffractionObject(wavelength=inputs[0], xarray=inputs[1], yarray=inputs[2], xtype=inputs[3])
+    actual = test.get_array_index(value=inputs[5], xtype=inputs[4])
+    assert actual == expected[0]
+
+
+def test_get_array_index_bad():
+    test = DiffractionObject(wavelength=2 * np.pi, xarray=np.array([]), yarray=np.array([]), xtype="tth")
+    with pytest.raises(ValueError, match=re.escape("The 'tth' array is empty. Please ensure it is initialized.")):
+        test.get_array_index(value=30)
+
+
 def test_dump(tmp_path, mocker):
     x, y = np.linspace(0, 5, 6), np.linspace(0, 5, 6)
     directory = Path(tmp_path)

tests/test_transforms.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from diffpy.utils.transforms import d_to_tth, q_to_tth, tth_to_d, tth_to_q
+from diffpy.utils.transforms import d_to_q, d_to_tth, q_to_d, q_to_tth, tth_to_d, tth_to_q
 
 params_q_to_tth = [
     # UC1: Empty q values, no wavelength, return empty arrays
@@ -64,7 +64,7 @@ def test_q_to_tth_bad(inputs, expected):
         np.array([0, 1, 2, 3, 4, 5]),
     ),
     # UC3: User specified valid tth values between 0-180 degrees (with wavelength)
-    # expected q vales are sin15, sin30, sin45, sin60, sin90
+    # expected q values are sin15, sin30, sin45, sin60, sin90
     (
         [4 * np.pi, np.array([0, 30.0, 60.0, 90.0, 120.0, 180.0])],
         np.array([0, 0.258819, 0.5, 0.707107, 0.866025, 1]),
@@ -98,6 +98,40 @@ def test_tth_to_q_bad(inputs, expected):
         tth_to_q(inputs[1], inputs[0])
 
 
+params_q_to_d = [
+    # UC1: User specified empty q values
+    ([np.array([])], np.array([])),
+    # UC2: User specified valid q values
+    (
+        [np.array([0, 1 * np.pi, 2 * np.pi, 3 * np.pi, 4 * np.pi, 5 * np.pi])],
+        np.array([np.inf, 2, 1, 0.66667, 0.5, 0.4]),
+    ),
+]
+
+
+@pytest.mark.parametrize("inputs, expected", params_q_to_d)
+def test_q_to_d(inputs, expected):
+    actual = q_to_d(inputs[0])
+    assert np.allclose(actual, expected)
+
+
+params_d_to_q = [
+    # UC1: User specified empty d values
+    ([np.array([])], np.array([])),
+    # 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]),
+    ),
+]
+
+
+@pytest.mark.parametrize("inputs, expected", params_d_to_q)
+def test_d_to_q(inputs, expected):
+    actual = d_to_q(inputs[0])
+    assert np.allclose(actual, expected)
+
+
 params_tth_to_d = [
     # UC0: User specified empty tth values (without wavelength)
     ([None, np.array([])], np.array([])),