nxs-analysis-tools 0.1.3__tar.gz → 0.1.5__tar.gz

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/PKG-INFO

@@ -1,30 +1,9 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.1.3
+Version: 0.1.5
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
-License: MIT License
-        
-        Copyright (c) 2023-2025 Steven J. Gomez Alvarado
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Download, https://pypi.org/project/nxs-analysis-tools/
 Project-URL: Bug Tracker, https://github.com/stevenjgomez/nxs_analysis_tools/issues
 Project-URL: Documentation, https://nxs-analysis-tools.readthedocs.io/en/stable/
@@ -33,7 +12,6 @@ Project-URL: DOI, https://doi.org/10.5281/zenodo.15186359
 Keywords: diffraction,xrd,nexusformat,nexus,nxs,scattering
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/pyproject.toml

@@ -6,11 +6,12 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.1.3'
+version = '0.1.5'
 description = 'Reduce and transform nexus format (.nxs) scattering data.'
 readme = 'README.md'
 requires-python = '>=3.7'
-license = { file = 'LICENSE' }
+license = "MIT"
+license-files = ['LICENSE']
 authors = [{ name = 'Steven J. Gomez Alvarado', email = 'stevenjgomez@ucsb.edu' }]
 
 keywords = [
@@ -24,7 +25,6 @@ keywords = [
 classifiers = [
     'Development Status :: 5 - Production/Stable',
     'Intended Audience :: Science/Research',
-    'License :: OSI Approved :: MIT License',
     'Programming Language :: Python',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3.9',
@@ -71,7 +71,7 @@ dev = [
 'DOI' = 'https://doi.org/10.5281/zenodo.15186359'
 
 [tool.bumpver]
-current_version = "0.1.3"
+current_version = "0.1.5"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
 tag_pattern = "vMAJOR.MINOR.PATCH[-TAG]"
 commit_message = "Bump version {old_version} -> {new_version}"

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/src/_meta/__init__.py

@@ -6,5 +6,5 @@ __author__ = 'Steven J. Gomez Alvarado'
 __email__ = 'stevenjgomez@ucsb.edu'
 __copyright__ = f"2023-2025, {__author__}"
 __license__ = 'MIT'
-__version__ = '0.1.3'
+__version__ = '0.1.5'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/src/nxs_analysis_tools/chess.py

@@ -173,7 +173,7 @@ class TempDependence:
         """
         for temperature in self.temperatures:
             self.scissors[temperature] = Scissors()
-            self.scissors[temperature] = LinecutModel()
+            self.linecutmodels[temperature] = LinecutModel()
 
     def set_data(self, temperature, data):
         """
@@ -188,7 +188,7 @@ class TempDependence:
         """
         self.datasets[temperature] = data
 
-    def load_transforms(self, temperatures_list=None, print_tree=True):
+    def load_transforms(self, temperatures_list=None, print_tree=True, use_nxlink=False):
         """
         Load transform datasets (from nxrefine) based on temperature.
 
@@ -196,8 +196,14 @@ class TempDependence:
         ----------
         temperatures_list : list of int or None, optional
             List of temperatures to load. If None, all available temperatures are loaded.
+        
         print_tree : bool, optional
             Whether to print the data tree upon loading. Default True.
+        
+        use_nxlink : bool, optional
+            If True, maintains the NXlink defined in the data file, which references
+            the raw data in the transform.nxs file. This saves memory when working with
+            many datasets. In this case, the axes are in reverse order. Default is False.
         """
         # Convert all temperatures to strings
         if temperatures_list:
@@ -240,7 +246,7 @@ class TempDependence:
 
             # Save dataset
             try:
-                self.datasets[self.temperatures[i]] = load_transform(path, print_tree)
+                self.datasets[self.temperatures[i]] = load_transform(path, print_tree=print_tree, use_nxlink=use_nxlink)
             except Exception as e:
                 # Report temperature that was unable to load, then raise exception.
                 temp_failed = self.temperatures[i]

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/src/nxs_analysis_tools/datareduction.py

@@ -49,7 +49,7 @@ def load_data(path, print_tree=True):
     return g.entry.data
 
 
-def load_transform(path, print_tree=True):
+def load_transform(path, print_tree=True, use_nxlink=False):
     """
     Load transform data from an nxrefine output file.
 
@@ -61,16 +61,24 @@ def load_transform(path, print_tree=True):
     print_tree : bool, optional
         If True, prints the NeXus data tree upon loading. Default is True.
 
+    use_nxlink : bool, optional
+        If True, maintains the NXlink defined in the data file, which references
+        the raw data in the transform.nxs file. This saves memory when working with
+        many datasets. In this case, the axes are in reverse order. Default is False.
+
     Returns
     -------
     data : NXdata
         The loaded transform data as an NXdata object.
     """
 
-    g = nxload(path)
+    root = nxload(path)
 
-    data = NXdata(NXfield(g.entry.transform.data.nxdata.transpose(2, 1, 0), name='counts'),
-                  (g.entry.transform.Qh, g.entry.transform.Qk, g.entry.transform.Ql))
+    if use_nxlink:
+        data = root.entry.transform
+    else:
+        data = NXdata(NXfield(root.entry.transform.data.nxdata.transpose(2, 1, 0), name='counts'),
+                      (root.entry.transform.Qh, root.entry.transform.Qk, root.entry.transform.Ql))
 
     print(data.tree) if print_tree else None
 
@@ -138,6 +146,36 @@ def rebin_3d(array):
 
     return rebinned
 
+def rebin_2d(array):
+    """
+    Rebins a 2D NumPy array by a factor of 2 along each dimension.
+
+    This function reduces the size of the input array by averaging over non-overlapping
+    2x2 blocks. Each dimension of the input array must be divisible by 2.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        A 2-dimensional NumPy array to be rebinned.
+
+    Returns
+    -------
+    np.ndarray
+        A rebinned array with shape (N//2, M//2) if the original shape was (N, M).
+    """
+
+    # Ensure the array shape is divisible by 2 in each dimension
+    shape = array.shape
+    if any(dim % 2 != 0 for dim in shape):
+        raise ValueError("Each dimension of the array must be divisible by 2 to rebin.")
+
+    # Reshape the array to group the data into 2x2 blocks
+    reshaped = array.reshape(shape[0] // 2, 2, shape[1] // 2, 2)
+
+    # Average over the 2x2 blocks
+    rebinned = reshaped.mean(axis=(1, 3))
+
+    return rebinned
 
 def rebin_1d(array):
     """
@@ -179,8 +217,7 @@ def rebin_nxdata(data):
       - Then, each axis is rebinned using `rebin_1d`.
 
     The signal array is similarly cropped to remove the last element along any dimension
-    with an odd shape, and then the data is averaged over 2x2x... blocks using the same
-    `rebin_1d` method (assumed to apply across 1D slices).
+    with an odd shape, and then the data is averaged over 2x2x... blocks.
 
     Parameters
     ----------
@@ -224,7 +261,12 @@ def rebin_nxdata(data):
     data_arr = data_arr[tuple(slice_obj)]
 
     # Perform actual rebinning
-    data_arr = rebin_3d(data_arr)
+    if data.ndim == 3:
+        data_arr = rebin_3d(data_arr)
+    elif data.ndim == 2:
+        data_arr = rebin_2d(data_arr)
+    elif data.ndim == 1:
+        data_arr = rebin_1d(data_arr)
 
     return NXdata(NXfield(data_arr, name=data.signal),
                   tuple([axis for axis in new_axes])
@@ -246,13 +288,15 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     data : :class:`nexusformat.nexus.NXdata` or ndarray
         The dataset to plot. Can be an `NXdata` object or a `numpy` array.
 
-    X : NXfield, optional
-        The X axis values. If None, a default range from 0 to the number of
-         columns in `data` is used.
+    X : ndarray or NXfield, optional
+        The values for the X axis. If `data` is an NXdata object and `X` is None, the X axis is
+        inherited from the NXdata object. If `data` is a NumPy ndarray and `X` is None, a default
+        range from 0 to the number of columns in `data` is used.
 
-    Y : NXfield, optional
-        The Y axis values. If None, a default range from 0 to the number of
-         rows in `data` is used.
+    Y : ndarray or NXfield, optional
+        The values for the Y axis. If `data` is an NXdata object and `Y` is None, the Y axis is
+        inherited from the NXdata object. If `data` is a NumPy ndarray and `Y` is None, a default
+        range from 0 to the number of rows in `data` is used.
 
     sum_axis : int, optional
         If the input data is 3D, this specifies the axis to sum over in order
@@ -327,9 +371,17 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     p : :class:`matplotlib.collections.QuadMesh`
         The `matplotlib` QuadMesh object representing the plotted data.
     """
+
+    # Some logic to control the processing of the arrays
     is_array = False
     is_nxdata = False
+    no_xy_provided = True
+
+    # If X,Y not provided by user
+    if X is not None and Y is not None:
+        no_xy_provided = False
 
+    # Examine data type to be plotted
     if isinstance(data, np.ndarray):
         is_array = True
     elif isinstance(data, (NXdata, NXfield)):
@@ -339,43 +391,72 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
                         f"Supported types are np.ndarray and NXdata.")
 
     # If three-dimensional, demand sum_axis to reduce to two dimensions.
-    if is_array and len(data.shape) == 3:
-        assert sum_axis is not None, "sum_axis must be specified when data is 3D."
-
-        data = data.sum(axis=sum_axis)
+    if data.ndim == 3:
+        assert sum_axis is not None, "sum_axis must be specified when data.ndim == 3."
 
-    if is_nxdata and len(data.shape) == 3:
-        assert sum_axis is not None, "sum_axis must be specified when data is 3D."
+        if is_array:
+            data = data.sum(axis=sum_axis)
+        elif is_nxdata:
+            arr = data.nxsignal.nxdata
+            arr = arr.sum(axis=sum_axis)
 
-        arr = data.nxsignal.nxdata
-        arr = arr.sum(axis=sum_axis)
+            # Create a 2D template from the original nxdata
+            slice_obj = [slice(None)] * len(data.shape)
+            slice_obj[sum_axis] = 0
 
-        # Create a 2D template from the original nxdata
-        slice_obj = [slice(None)] * len(data.shape)
-        slice_obj[sum_axis] = 0
-
-        # Use the 2D template to create a new nxdata
-        data = array_to_nxdata(arr, data[slice_obj])
+            # Use the 2D template to create a new nxdata
+            data = array_to_nxdata(arr, data[slice_obj])
 
+    # If the data is of type ndarray, then convert to NXdata
     if is_array:
+        # Convert X to NXfield if it is not already
         if X is None:
-            X = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='x')
+            X = NXfield(np.arange(data.shape[0]), name='x')
+        elif isinstance(X, np.ndarray):
+            X = NXfield(X, name='x')
+        elif isinstance(X, NXfield):
+            pass
+        else:
+            raise TypeError("X must be of type np.ndarray or NXdata")
+
+        # Convert Y to NXfield if it is not already
         if Y is None:
-            Y = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='y')
+            Y = NXfield(np.arange(data.shape[1]), name='y')
+        elif isinstance(Y, np.ndarray):
+            Y = NXfield(Y, name='y')
+        elif isinstance(Y, NXfield):
+            pass
+        else:
+            raise TypeError("Y must be of type np.ndarray or NXdata")
+
         if transpose:
             X, Y = Y, X
             data = data.transpose()
+
         data = NXdata(NXfield(data, name='value'), (X, Y))
-        data_arr = data[data.signal].nxdata.transpose()
+        data_arr = data.nxsignal.nxdata.transpose()
+    # Otherwise, if data is of type NXdata, then decide whether to create axes,
+    # use provided axes, or inherit axes.
     elif is_nxdata:
         if X is None:
-            X = data[data.axes[0]]
+            X = data.nxaxes[0]
+        elif isinstance(X, np.ndarray):
+            X = NXfield(X, name='x')
+        elif isinstance(X, NXdata):
+            pass
         if Y is None:
-            Y = data[data.axes[1]]
+            Y = data.nxaxes[1]
+        elif isinstance(Y, np.ndarray):
+            Y = NXfield(Y, name='y')
+        elif isinstance(Y, NXdata):
+            pass
+
+        # Transpose axes and data if specified
         if transpose:
             X, Y = Y, X
             data = data.transpose()
-        data_arr = data[data.signal].nxdata.transpose()
+
+        data_arr = data.nxsignal.nxdata.transpose()
 
     # Display Markdown heading
     if mdheading is None:
@@ -407,6 +488,7 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     elif logscale:
         norm = colors.LogNorm(vmin=vmin, vmax=vmax)
 
+
     # Plot data
     p = ax.pcolormesh(X.nxdata, Y.nxdata, data_arr, shading='auto', norm=norm, cmap=cmap, **kwargs)
 
@@ -448,14 +530,15 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     # Correct aspect ratio for the x/y axes after transformation
     ax.set(aspect=np.cos(skew_angle_adj * np.pi / 180))
 
-    # Add tick marks all around
-    ax.tick_params(direction='in', top=True, right=True, which='both')
 
     # Automatically set tick locations, only if NXdata or if X,Y axes are provided for an array
-    if is_nxdata or (is_array and (X is not None and Y is not None)):
+    if is_nxdata or (is_array and (no_xy_provided == False)):
         # Add default minor ticks on x
         ax.xaxis.set_minor_locator(MultipleLocator(1))
 
+        # Add tick marks all around
+        ax.tick_params(direction='in', top=True, right=True, which='both')
+
         if xticks is not None:
             # Use user provided values
             ax.xaxis.set_major_locator(MultipleLocator(xticks))
@@ -466,6 +549,9 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
         if yticks is not None:
             # Use user provided values
             ax.yaxis.set_major_locator(MultipleLocator(yticks))
+    else:
+        # Add tick marks all around
+        ax.tick_params(direction='in', top=True, right=True, which='major')
 
     # Apply transform to tick marks
     for i in range(0, len(ax.xaxis.get_ticklines())):
@@ -753,8 +839,8 @@ class Scissors:
         slice_obj[2] = center[2]
 
         p1 = plot_slice(data[slice_obj],
-                        X=data[data.axes[0]],
-                        Y=data[data.axes[1]],
+                        X=data.nxaxes[0],
+                        Y=data.nxaxes[1],
                         ax=axes[0],
                         **kwargs)
         ax = axes[0]
@@ -777,8 +863,8 @@ class Scissors:
         slice_obj[1] = center[1]
 
         p2 = plot_slice(data[slice_obj],
-                        X=data[data.axes[0]],
-                        Y=data[data.axes[2]],
+                        X=data.nxaxes[0],
+                        Y=data.nxaxes[2],
                         ax=axes[1],
                         **kwargs)
         ax = axes[1]
@@ -801,8 +887,8 @@ class Scissors:
         slice_obj[0] = center[0]
 
         p3 = plot_slice(data[slice_obj],
-                        X=data[data.axes[1]],
-                        Y=data[data.axes[2]],
+                        X=data.nxaxes[1],
+                        Y=data.nxaxes[2],
                         ax=axes[2],
                         **kwargs)
         ax = axes[2]
@@ -849,31 +935,31 @@ class Scissors:
         slice_obj = [slice(None)] * data.ndim
         slice_obj[2] = center[2]
         p1 = plot_slice(data[slice_obj],
-                        X=data[data.axes[0]],
-                        Y=data[data.axes[1]],
+                        X=data.nxaxes[0],
+                        Y=data.nxaxes[1],
                         ax=axes[0],
                         **kwargs)
-        axes[0].set_aspect(len(data[data.axes[0]].nxdata) / len(data[data.axes[1]].nxdata))
+        axes[0].set_aspect(len(data.nxaxes[0].nxdata) / len(data.nxaxes[1].nxdata))
 
         # Plot cross section 2
         slice_obj = [slice(None)] * data.ndim
         slice_obj[1] = center[1]
         p3 = plot_slice(data[slice_obj],
-                        X=data[data.axes[0]],
-                        Y=data[data.axes[2]],
+                        X=data.nxaxes[0],
+                        Y=data.nxaxes[2],
                         ax=axes[1],
                         **kwargs)
-        axes[1].set_aspect(len(data[data.axes[0]].nxdata) / len(data[data.axes[2]].nxdata))
+        axes[1].set_aspect(len(data.nxaxes[0].nxdata) / len(data.nxaxes[2].nxdata))
 
         # Plot cross-section 3
         slice_obj = [slice(None)] * data.ndim
         slice_obj[0] = center[0]
         p2 = plot_slice(data[slice_obj],
-                        X=data[data.axes[1]],
-                        Y=data[data.axes[2]],
+                        X=data.nxaxes[1],
+                        Y=data.nxaxes[2],
                         ax=axes[2],
                         **kwargs)
-        axes[2].set_aspect(len(data[data.axes[1]].nxdata) / len(data[data.axes[2]].nxdata))
+        axes[2].set_aspect(len(data.nxaxes[1].nxdata) / len(data.nxaxes[2].nxdata))
 
         # Adjust subplot padding
         fig.subplots_adjust(wspace=0.3)
@@ -984,7 +1070,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         Rotated data as an NXdata object.
     """
     # Define output array
-    output_array = np.zeros(data[data.signal].shape)
+    output_array = np.zeros(data.nxsignal.shape)
 
     # Define shear transformation
     skew_angle_adj = 90 - lattice_angle
@@ -1085,7 +1171,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
             output_array[:, :, i] = counts_unpadded
     print('\nDone.')
     return NXdata(NXfield(output_array, name=p.padded.signal),
-                  (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
+                  (data.nxaxes[0], data.nxaxes[1], data.nxaxes[2]))
 
 
 def rotate_data_2D(data, lattice_angle, rotation_angle):
@@ -1180,7 +1266,7 @@ def rotate_data_2D(data, lattice_angle, rotation_angle):
 
     print('\nDone.')
     return NXdata(NXfield(counts_unpadded, name=p.padded.signal),
-                  (data[data.axes[0]], data[data.axes[1]]))
+                  (data.nxaxes[0], data.nxaxes[1]))
 
 
 class Padder:
@@ -1265,7 +1351,7 @@ class Padder:
         data = self.data
         self.padding = padding
 
-        padded_shape = tuple(data[data.signal].nxdata.shape[i]
+        padded_shape = tuple(data.nxsignal.nxdata.shape[i]
                              + self.padding[i] * 2 for i in range(data.ndim))
 
         # Create padded dataset
@@ -1275,7 +1361,7 @@ class Padder:
         for i, _ in enumerate(slice_obj):
             slice_obj[i] = slice(self.padding[i], -self.padding[i], None)
         slice_obj = tuple(slice_obj)
-        padded[slice_obj] = data[data.signal].nxdata
+        padded[slice_obj] = data.nxsignal.nxdata
 
         padmaxes = tuple(self.maxes[i] + self.padding[i] * self.steps[i]
                          for i in range(data.ndim))

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/src/nxs_analysis_tools/pairdistribution.py

@@ -1039,6 +1039,8 @@ class Interpolator:
             The dataset containing the data to be interpolated.
         """
         self.data = data
+        self.interpolated = data
+        self.tapered = data
 
     def set_kernel(self, kernel):
         """
@@ -1198,6 +1200,82 @@ class Interpolator:
 
         self.window = window
 
+    def set_ellipsoidal_tukey_window(self, tukey_alpha=1.0, coeffs=None):
+        """
+        Set an ellipsoidal Tukey window function for data tapering.
+
+        The Tukey window smoothly tapers the data to zero near the edges of the
+        elliptical region defined by quadratic form coefficients. This helps reduce
+        artifacts in Fourier transforms and other operations sensitive to boundary effects.
+
+        Parameters
+        ----------
+        tukey_alpha : float, optional
+            Tapering parameter for the Tukey window, between 0 and 1.
+            - `tukey_alpha = 0` results in a ellipsoidal window (no tapering).
+            - `tukey_alpha = 1` results in a full cosine taper.
+            Default is 1.0.
+
+        coeffs : tuple of float, optional
+            Coefficients `(c0, c1, c2, c3, c4, c5)` defining the ellipsoidal
+            quadratic form:
+                R^2 = c0*H^2 + c1*H*K + c2*K^2 + c3*K*L + c4*L^2 + c5*L*H
+            If None, coefficients are automatically set to match the edges of the
+            reciprocal space axes (H, K, L), which should be appropriate in cases
+            where H, K, and L are orthogonal.
+
+        Notes
+        -----
+        - The maximum allowed radius `Qmax` is determined from the minimum radius
+          value along the edges of reciprocal space.
+        - The Tukey window is applied radially as a function of the distance `R`
+          from the center, defined by the ellipsoidal quadratic form.
+
+        Sets
+        ----
+        self.window : ndarray
+            A 3D array of the same shape as the data, containing the Tukey window
+            values between 0 and 1.
+        """
+
+        # Initialize axes
+        H,K,L = [axis for axis in self.data.nxaxes]
+
+        # Initialize coeffs (default to window reaching edge of array)
+        smallest_extent = np.min([H.max(), K.max(), L.max()])
+        c = coeffs if coeffs is not None else ((smallest_extent / H.max()) ** 2,
+                                               0,
+                                               (smallest_extent / K.max()) ** 2,
+                                               0,
+                                               (smallest_extent / L.max()) ** 2,
+                                               0
+                                               )
+
+        # Create meshgrid
+        HH, KK, LL = np.meshgrid(H,K,L, indexing='ij')
+
+        # Create radius array
+        RR = np.sqrt(
+            c[0] * HH ** 2 +
+            c[1] * HH * KK +
+            c[2] * KK ** 2 +
+            c[3] * KK * LL +
+            c[4] * LL ** 2 +
+            c[5] * LL * HH
+        )
+
+        # Check the edges of reciprocal space to verify Qmax
+        # Create list of pixels where H = H.max() or K = K.max() or L = L.max()
+        edges = np.where(np.logical_or(np.logical_or(HH == H.max(), KK == K.max()), LL == L.max()), RR, RR.max())
+        Qmax = edges.min()
+        alpha = tukey_alpha
+        period = (Qmax * alpha) / np.pi
+
+        window = np.where(RR > Qmax * (1 - alpha), (np.cos((RR - Qmax * (1 - alpha)) / period) + 1) / 2, 1)
+        window = np.where(RR > Qmax, 0, window)
+
+        self.window = window
+
     def set_window(self, window):
         """
         Set a custom window function for data tapering.
@@ -1578,6 +1656,41 @@ class DeltaPDF:
         self.interpolator.set_hexagonal_tukey_window(tukey_alphas)
         self.window = self.interpolator.window
 
+    def set_ellipsoidal_tukey_window(self, tukey_alpha=1.0, coeffs=None):
+        """
+        Set an ellipsoidal Tukey window function for data tapering.
+
+        The Tukey window smoothly tapers the data to zero near the edges of the
+        elliptical region defined by quadratic form coefficients. This helps reduce
+        artifacts in Fourier transforms and other operations sensitive to boundary effects.
+
+        Parameters
+        ----------
+        tukey_alpha : float, optional
+            Tapering parameter for the Tukey window, between 0 and 1.
+            - `tukey_alpha = 0` results in a ellipsoidal window (no tapering).
+            - `tukey_alpha = 1` results in a full cosine taper.
+            Default is 1.0.
+
+        coeffs : tuple of float, optional
+            Coefficients `(c0, c1, c2, c3, c4, c5)` defining the ellipsoidal
+            quadratic form:
+                R^2 = c0*H^2 + c1*H*K + c2*K^2 + c3*K*L + c4*L^2 + c5*L*H
+            If None, coefficients are automatically set to match the edges of the
+            reciprocal space axes (H, K, L), which should be appropriate in cases
+            where H, K, and L are orthogonal.
+
+        Notes
+        -----
+        - The maximum allowed radius `Qmax` is determined from the minimum radius
+          value along the edges of reciprocal space.
+        - The Tukey window is applied radially as a function of the distance `R`
+          from the center, defined by the ellipsoidal quadratic form.
+        """
+        self.interpolator.set_ellipsoidal_tukey_window(tukey_alpha=tukey_alpha, coeffs=coeffs)
+        self.window = self.interpolator.window
+
+
     def set_window(self, window):
         """
         Set a custom window function for data tapering.

{nxs_analysis_tools-0.1.3 → nxs_analysis_tools-0.1.5}/src/nxs_analysis_tools.egg-info/SOURCES.txt

@@ -13,10 +13,12 @@ tests/test_accurate_highlight.py
 tests/test_chess.py
 tests/test_chess_fitting.py
 tests/test_datareduction.py
+tests/test_ellipsoidal_window.py
 tests/test_fitting.py
 tests/test_lmfit.py
 tests/test_mask_plotting.py
 tests/test_pairdistribution.py
+tests/test_plot_slice_axes_types.py
 tests/test_plot_slice_with_ndarray.py
 tests/test_rotate_data.py
 tests/test_sum_axis.py

nxs_analysis_tools-0.1.5/tests/test_ellipsoidal_window.py

@@ -0,0 +1,15 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from nxs_analysis_tools import *
+
+from nxs_analysis_tools.pairdistribution import Interpolator
+
+data = load_data('docs/source/examples/example_data/plot_slice_data/cubic_hkli.nxs')
+h = Interpolator()
+h.set_data(data)
+h.set_ellipsoidal_tukey_window(tukey_alpha=0.0)
+h.apply_window()
+fig,axs = plt.subplots(2,1, figsize=(4,8), dpi=100)
+plot_slice(h.tapered[:,:,0.0], vmin=0, vmax=0.01, ax=axs[0])
+plot_slice(h.tapered[:,0.0,:], vmin=0, vmax=0.01, ax=axs[1])
+plt.show()

nxs_analysis_tools-0.1.5/tests/test_plot_slice_axes_types.py

@@ -0,0 +1,40 @@
+from src.nxs_analysis_tools import *
+import matplotlib.pyplot as plt
+import numpy as np
+
+data = load_data('../docs/source/examples/example_data/plot_slice_data/cubic_hkli.nxs')
+
+# NXdata with inherent axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0], ax=ax)
+# plt.show()
+
+# NXdata with NXfield axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0],X=data.nxaxes[0]*2,Y=data.nxaxes[1]*2, ax=ax)
+# plt.show()
+
+# NXdata with ndarray axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0],X=np.linspace(-0.1,0.1,len(data.nxaxes[0])),Y=np.linspace(-0.3,0.3,len(data.nxaxes[1])), ax=ax)
+# plt.show()
+
+# ndarray with inherent axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0].counts.nxdata, ax=ax)
+# plt.show()
+
+# ndarray with NXfield axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0].counts.nxdata,X=data.nxaxes[0]*2,Y=data.nxaxes[1]*2, ax=ax)
+# plt.show()
+
+# ndarray with ndarray axes
+_,ax = plt.subplots()
+plot_slice(data[:,:,0.0].counts.nxdata,X=np.linspace(-0.1,0.1,len(data.nxaxes[0])),Y=np.linspace(-0.3,0.3,len(data.nxaxes[1])), ax=ax)
+# plt.show()
+
+# ndarray with invalid axes
+# _,ax = plt.subplots()
+# plot_slice(data[:,:,0.0].counts.nxdata,X='test',Y='test', ax=ax)
+# plt.show()