Merge branch 'main' into no-empty-object

Author: bobleesj

doc/source/examples/resampleexample.rst

@@ -58,7 +58,7 @@ given enough datapoints.
      nickel_resample = wsinterp(grid, nickel_grid, nickel_func)
      target_resample = wsinterp(grid, target_grid, target_func)
 
-   We can now plot the difference to see that these two functions are quite similar.:
+   We can now plot the difference to see that these two functions are quite similar.::
 
      plt.plot(grid, target_resample)
      plt.plot(grid, nickel_resample)
@@ -78,3 +78,10 @@ given enough datapoints.
    In the case of our dataset, our band-limit is ``qmax=25.0`` and our function spans :math:`r \in (0.0, 60.0)`.
    Thus, our original grid requires :math:`25.0 * 60.0 / \pi < 478`. Since our grid has :math:`601` datapoints, our
    reconstruction was perfect as shown from the comparison between ``Nickel.gr`` and ``NiTarget.gr``.
+
+   This computation is implemented in the function ``nsinterp``.::
+
+     from diffpy.utils.resampler import nsinterp
+     qmin = 0
+     qmax = 25
+     nickel_resample = (nickel_grid, nickel_func, qmin, qmax)

news/nsinterp.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* Function nsinterp for automatic interpolation onto the Nyquist-Shannon grid.
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

news/resample-dep.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* <news item>
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* `resample` function in resampler. Replaced with `wsinterp` with better functionality.
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

news/rm-range-methods.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* <news item>
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* `set_angles_from_list`, `set_angles_from`, `set_qs_from_range` methods in `DiffractionObject`
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

src/diffpy/utils/diffraction_objects.py

@@ -270,73 +270,6 @@ def id(self):
     def id(self, _):
         raise AttributeError(_setter_wmsg("id"))
 
-    def set_angles_from_list(self, angles_list):
-        self.angles = angles_list
-        self.n_steps = len(angles_list) - 1.0
-        self.begin_angle = self.angles[0]
-        self.end_angle = self.angles[-1]
-
-    def set_qs_from_range(self, begin_q, end_q, step_size=None, n_steps=None):
-        """
-        create an array of linear spaced Q-values
-
-        Parameters
-        ----------
-        begin_q float
-          the beginning angle
-        end_q float
-          the ending angle
-        step_size float
-          the size of the step between points.  Only specify step_size or n_steps, not both
-        n_steps integer
-          the number of steps.  Odd numbers are preferred. Only specify step_size or n_steps, not both
-
-        Returns
-        -------
-        Sets self.qs
-        self.qs array of floats
-          the q values in the independent array
-
-        """
-        self.qs = self._set_array_from_range(begin_q, end_q, step_size=step_size, n_steps=n_steps)
-
-    def set_angles_from_range(self, begin_angle, end_angle, step_size=None, n_steps=None):
-        """
-        create an array of linear spaced angle-values
-
-        Parameters
-        ----------
-        begin_angle float
-          the beginning angle
-        end_angle float
-          the ending angle
-        step_size float
-          the size of the step between points.  Only specify step_size or n_steps, not both
-        n_steps integer
-          the number of steps.  Odd numbers are preferred. Only specify step_size or n_steps, not both
-
-        Returns
-        -------
-        Sets self.angles
-        self.angles array of floats
-          the q values in the independent array
-
-        """
-        self.angles = self._set_array_from_range(begin_angle, end_angle, step_size=step_size, n_steps=n_steps)
-
-    def _set_array_from_range(self, begin, end, step_size=None, n_steps=None):
-        if step_size is not None and n_steps is not None:
-            print(
-                "WARNING: both step_size and n_steps have been given.  n_steps will be used and step_size will be "
-                "reset."
-            )
-            array = np.linspace(begin, end, n_steps)
-        elif step_size is not None:
-            array = np.arange(begin, end, step_size)
-        elif n_steps is not None:
-            array = np.linspace(begin, end, n_steps)
-        return array
-
     def get_array_index(self, value, xtype=None):
         """
         Return the index of the closest value in the array associated with the specified xtype.

src/diffpy/utils/resampler.py

@@ -15,6 +15,8 @@
 
 """Various utilities related to data parsing and manipulation."""
 
+import warnings
+
 import numpy as np
 
 
@@ -77,6 +79,46 @@ def wsinterp(x, xp, fp, left=None, right=None):
     return fp_at_x
 
 
+def nsinterp(xp, fp, qmin=0, qmax=25, left=None, right=None):
+    """One-dimensional Whittaker-Shannon interpolation onto the Nyquist-Shannon grid.
+
+    Takes a band-limited function fp and original grid xp and resamples fp on the NS grid.
+    Uses the minimum number of points N required by the Nyquist sampling theorem.
+    N = (qmax-qmin)(rmax-rmin)/pi, where rmin and rmax are the ends of the real-space ranges.
+    fp must be finite, and the user inputs qmin and qmax of the frequency-domain.
+
+    Parameters
+    ----------
+    xp: ndarray
+        The array of known x values.
+    fp: ndarray
+        The array of y values associated with xp.
+    qmin: float
+        The lower band limit in the frequency domain.
+    qmax: float
+        The upper band limit in the frequency domain.
+
+    Returns
+    -------
+    x: ndarray
+        The Nyquist-Shannon grid computed for the given qmin and qmax.
+    fp_at_x: ndarray
+        The interpolated values at points x. Returns a single float if x is a scalar,
+        otherwise returns a numpy.ndarray.
+    """
+    # Ensure numpy array
+    xp = np.array(xp)
+    rmin = np.min(xp)
+    rmax = np.max(xp)
+
+    nspoints = int(np.round((qmax - qmin) * (rmax - rmin) / np.pi))
+
+    x = np.linspace(rmin, rmax, nspoints)
+    fp_at_x = wsinterp(x, xp, fp)
+
+    return x, fp_at_x
+
+
 def resample(r, s, dr):
     """Resample a PDF on a new grid.
 
@@ -97,6 +139,13 @@ def resample(r, s, dr):
     Returns resampled (r, s).
     """
 
+    warnings.warn(
+        "The 'resample' function is deprecated and will be removed in a future release (3.8.0). \n"
+        "'resample' has been renamed 'wsinterp' to better reflect functionality. Please use 'wsinterp' instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     dr0 = r[1] - r[0]  # Constant timestep
 
     if dr0 < dr:

tests/conftest.py

@@ -35,5 +35,11 @@ def _load(filename):
 
 @pytest.fixture
 def do_minimal():
-    # Create an instance of DiffractionObject with minimal setup
+    # Create an instance of DiffractionObject with empty xarray and yarray values, and a non-empty wavelength
     return DiffractionObject(xarray=np.empty(0), yarray=np.empty(0), xtype="tth", wavelength=1.54)
+
+@pytest.fixture
+def do_minimal_tth():
+    # Create an instance of DiffractionObject with non-empty xarray, yarray, and wavelength values
+    return DiffractionObject(wavelength=2 * np.pi, xarray=np.array([30, 60]), yarray=np.array([1, 2]), xtype="tth")
+

tests/test_diffraction_objects.py

@@ -137,12 +137,20 @@ def test_diffraction_objects_equality(inputs1, inputs2, expected):
     assert (do_1 == do_2) == expected
 
 
-def test_on_xtype():
-    do = DiffractionObject(wavelength=2 * np.pi, xarray=np.array([30, 60]), yarray=np.array([1, 2]), xtype="tth")
-    assert np.allclose(do.on_xtype("tth"), [np.array([30, 60]), np.array([1, 2])])
-    assert np.allclose(do.on_xtype("2theta"), [np.array([30, 60]), np.array([1, 2])])
-    assert np.allclose(do.on_xtype("q"), [np.array([0.51764, 1]), np.array([1, 2])])
-    assert np.allclose(do.on_xtype("d"), [np.array([12.13818, 6.28319]), np.array([1, 2])])
+@pytest.mark.parametrize(
+    "xtype, expected_xarray",
+    [
+        ("tth", np.array([30, 60])),
+        ("2theta", np.array([30, 60])),
+        ("q", np.array([0.51764, 1])),
+        ("d", np.array([12.13818, 6.28319])),
+    ],
+)
+def test_on_xtype(xtype, expected_xarray, do_minimal_tth):
+    do = do_minimal_tth
+    actual_xrray, actual_yarray = do.on_xtype(xtype)
+    assert np.allclose(actual_xrray, expected_xarray)
+    assert np.allclose(actual_yarray, np.array([1, 2]))
 
 
 def test_init_invalid_xtype():

tests/test_resample.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from diffpy.utils.resampler import wsinterp
+from diffpy.utils.resampler import nsinterp, wsinterp
 
 
 def test_wsinterp():
@@ -30,3 +30,23 @@ def test_wsinterp():
         assert np.allclose(fp_at_x[1:-1], fp)
         for i in range(len(x)):
             assert fp_at_x[i] == pytest.approx(wsinterp(x[i], xp, fp))
+
+
+def test_nsinterp():
+    # Create a cosine function cos(2x) for x \in [0, 3pi]
+    xp = np.linspace(0, 3 * np.pi, 100)
+    fp = np.cos(2 * xp)
+
+    # Want to resample onto the grid {0, pi, 2pi, 3pi}
+    x = np.array([0, np.pi, 2 * np.pi, 3 * np.pi])
+
+    # Get wsinterp result
+    ws_f = wsinterp(x, xp, fp)
+
+    # Use nsinterp with qmin-qmax=4/3
+    qmin = np.random.uniform()
+    qmax = qmin + 4 / 3
+    ns_x, ns_f = nsinterp(xp, fp, qmin, qmax)
+
+    assert np.allclose(x, ns_x)
+    assert np.allclose(ws_f, ns_f)