public functions now operate on 1D x-arrays only for ease of user use

Author: sbillinge

src/diffpy/utils/transforms.py

@@ -18,16 +18,16 @@
 )
 
 
-def _validate_inputs(on_q, wavelength):
+def _validate_inputs(q, wavelength):
     if wavelength is None:
         warnings.warn(wavelength_warning_emsg, UserWarning)
         return np.empty(0)
     pre_factor = wavelength / (4 * np.pi)
-    if np.any(np.abs(on_q[0] * pre_factor) > 1.0):
+    if np.any(np.abs(q * pre_factor) > 1.0):
         raise ValueError(invalid_q_or_wavelength_emsg)
 
 
-def q_to_tth(on_q, wavelength):
+def q_to_tth(q, wavelength):
     r"""
     Helper function to convert q to two-theta.
 
@@ -47,34 +47,33 @@ def q_to_tth(on_q, wavelength):
 
     Parameters
     ----------
-    on_q : 2D array
-        The array of :math:`q` values and :math: 'i' intensity values, np.array([[qs], [is]]).
-        This is the same format as, and so can accept, diffpy.utils.DiffractionOject.on_q
+    q : 1D array
+        The array of :math:`q` values numpy.array([qs]).
         The units of q must be reciprocal of the units of wavelength.
 
     wavelength : float
         Wavelength of the incoming x-rays/neutrons/electrons
 
     Returns
     -------
-    on_tth : 2D array
-        The array of :math:`2\theta` values in degrees and :math: 'i' intensity values unchanged,
-        np.array([[tths], [is]]).
+    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(on_q, wavelength)
-    on_q.astype(np.float64)
-    on_tth = copy(on_q)  # initialize output array of same shape
+    _validate_inputs(q, wavelength)
+    q.astype(np.float64)
+    tth = copy(q)  # initialize output array of same shape
     if wavelength is not None:
-        on_tth[0] = np.rad2deg(2.0 * np.arcsin(on_q[0] * wavelength / (4 * np.pi)))
+        tth = np.rad2deg(2.0 * np.arcsin(q * wavelength / (4 * np.pi)))
     else:  # return intensities vs. an x-array that is just the index
-        for i, _ in enumerate(on_q[0]):
-            on_tth[0][i] = i
-    return on_tth
+        for i, _ in enumerate(q):
+            tth[i] = i
+    return tth
 
 
-def tth_to_q(on_tth, wavelength):
+def tth_to_q(tth, wavelength):
     r"""
+
     Helper function to convert two-theta to q on independent variable axis.
 
     If wavelength is missing, returns independent variable axis as integer indexes.
@@ -93,7 +92,7 @@ def tth_to_q(on_tth, wavelength):
 
     Parameters
     ----------
-    on_tth : 2D array
+    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
         The units of tth are expected in degrees.
@@ -109,14 +108,14 @@ def tth_to_q(on_tth, wavelength):
         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
     """
-    on_tth.astype(np.float64)
-    if np.any(np.deg2rad(on_tth[0]) > np.pi):
+    tth.astype(np.float64)
+    if np.any(np.deg2rad(tth) > np.pi):
         raise ValueError(invalid_tth_emsg)
-    on_q = copy(on_tth)
+    q = copy(tth)
     if wavelength is not None:
         pre_factor = (4.0 * np.pi) / wavelength
-        on_q[0] = pre_factor * np.sin(np.deg2rad(on_tth[0] / 2))
+        q = pre_factor * np.sin(np.deg2rad(tth / 2))
     else:  # return intensities vs. an x-array that is just the index
-        for i, _ in enumerate(on_q[0]):
-            on_q[0][i] = i
-    return on_q
+        for i, _ in enumerate(q):
+            q[i] = i
+    return q

tests/test_transforms.py

@@ -5,31 +5,30 @@
 
 params_q_to_tth = [
     # UC1: Empty q values, no wavelength, return empty arrays
-    ([None, np.empty((2, 0))], np.empty((2, 0))),
+    ([None, np.empty((1,))], np.empty((1,))),
     # UC2: Empty q values, wavelength specified, return empty arrays
-    ([4 * np.pi, np.empty((2, 0))], np.empty((2, 0))),
+    ([4 * np.pi, np.empty((1,))], np.empty((1,))),
     # UC3: User specified valid q values, no wavelength, return empty arrays
     (
-        [None, np.array([[0, 0.2, 0.4, 0.6, 0.8, 1], [1, 2, 3, 4, 5, 6]])],
-        np.array([[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6]]),
+        [None, np.array([0, 0.2, 0.4, 0.6, 0.8, 1])],
+        np.array([0, 1, 2, 3, 4, 5]),
     ),
     # UC4: User specified valid q values (with wavelength)
     # expected tth values are 2*arcsin(q) in degrees
-    ([4 * np.pi, np.array([[0, 1 / np.sqrt(2), 1.0], [1, 2, 3]])], np.array([[0, 90.0, 180.0], [1, 2, 3]])),
+    ([4 * np.pi, np.array([0, 1 / np.sqrt(2), 1.0])], np.array([0, 90.0, 180.0])),
 ]
 
 
 @pytest.mark.parametrize("inputs, expected", params_q_to_tth)
 def test_q_to_tth(inputs, expected):
     actual = q_to_tth(inputs[1], inputs[0])
-    assert np.allclose(expected[0], actual[0])
-    assert np.allclose(expected[1], actual[1])
+    assert np.allclose(expected, actual)
 
 
 params_q_to_tth_bad = [
     # UC1: user specified invalid q values that result in tth > 180 degrees
     (
-        [4 * np.pi, np.array([[0.2, 0.4, 0.6, 0.8, 1, 1.2], [1, 2, 3, 4, 5, 6]])],
+        [4 * np.pi, np.array([0.2, 0.4, 0.6, 0.8, 1, 1.2])],
         [
             ValueError,
             "The supplied q-array and wavelength will result in an impossible two-theta. "
@@ -38,7 +37,7 @@ def test_q_to_tth(inputs, expected):
     ),
     # UC2: user specified a wrong wavelength that result in tth > 180 degrees
     (
-        [100, np.array([[0, 0.2, 0.4, 0.6, 0.8, 1], [1, 2, 3, 4, 5, 6]])],
+        [100, np.array([0, 0.2, 0.4, 0.6, 0.8, 1])],
         [
             ValueError,
             "The supplied q-array and wavelength will result in an impossible two-theta. "
@@ -56,19 +55,19 @@ def test_q_to_tth_bad(inputs, expected):
 
 params_tth_to_q = [
     # UC0: User specified empty tth values (without wavelength)
-    ([None, np.array([[], []])], np.array([[], []])),
+    ([None, np.array([])], np.array([])),
     # UC1: User specified empty tth values (with wavelength)
-    ([4 * np.pi, np.array([[], []])], np.array([[], []])),
+    ([4 * np.pi, np.array([])], np.array([])),
     # UC2: User specified valid tth values between 0-180 degrees (without wavelength)
     (
-        [None, np.array([[0, 30, 60, 90, 120, 180], [1, 2, 3, 4, 5, 6]])],
-        np.array([[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6]]),
+        [None, np.array([0, 30, 60, 90, 120, 180])],
+        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
     (
-        [4 * np.pi, np.array([[0, 30.0, 60.0, 90.0, 120.0, 180.0], [1, 2, 3, 4, 5, 6]])],
-        np.array([[0, 0.258819, 0.5, 0.707107, 0.866025, 1], [1, 2, 3, 4, 5, 6]]),
+        [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]),
     ),
 ]
 
@@ -82,12 +81,12 @@ def test_tth_to_q(inputs, expected):
 params_tth_to_q_bad = [
     # UC0: user specified an invalid tth value of > 180 degrees (without wavelength)
     (
-        [None, np.array([[0, 30, 60, 90, 120, 181], [1, 2, 3, 4, 5, 6]])],
+        [None, np.array([0, 30, 60, 90, 120, 181])],
         [ValueError, "Two theta exceeds 180 degrees. Please check the input values for errors."],
     ),
     # UC1: user specified an invalid tth value of > 180 degrees (with wavelength)
     (
-        [4 * np.pi, np.array([[0, 30, 60, 90, 120, 181], [1, 2, 3, 4, 5, 6]])],
+        [4 * np.pi, np.array([0, 30, 60, 90, 120, 181])],
         [ValueError, "Two theta exceeds 180 degrees. Please check the input values for errors."],
     ),
 ]