nxs-analysis-tools 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

_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.9'
+__version__ = '0.1.11'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

nxs_analysis_tools/__init__.py

@@ -9,7 +9,7 @@ from .chess import TempDependence
 
 # What to import when running "from nxs_analysis_tools import *"
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
-           'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
+           'reciprocal_lattice_params', 'rotate_data',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
            'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'TempDependence',
            'animate_slice_temp', 'animate_slice_axis']

nxs_analysis_tools/chess.py

@@ -1,7 +1,7 @@
 """
 This module provides classes and functions for analyzing scattering datasets collected at CHESS
-(ID4B) with temperature dependence. It includes functions for loading data, cutting data, and
-plotting linecuts.
+(ID4B) with temperature dependence. It includes functions for loading temperature series and 
+performing operations on all datasets in the series at once (e.g., cutting, fitting). 
 """
 import os
 import re
@@ -59,10 +59,11 @@ class TempDependence:
         Initialize Scissors and LinecutModel objects for each temperature.
     set_data(temperature, data):
         Set the dataset for a specific temperature.
-    load_transforms(temperatures_list=None, print_tree=True):
+    load_transforms(temperatures_list=None, exclude_temperatures=None, print_tree=True):
         Load transform datasets (from nxrefine) based on temperature.
-    load_datasets(file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
-        Load datasets (CHESS format) from the specified folder.
+    load_datasets(file_ending='hkli.nxs', temperatures_list=None, exclude_temperatures=None, 
+                  print_tree=True):
+        Load datasets (legacy CHESS format) from the specified folder.
     get_sample_directory():
         Get the folder path where the datasets are located.
     clear_datasets():
@@ -99,11 +100,12 @@ class TempDependence:
         Fit the line cut models for each temperature.
     plot_fit(mdheadings=False, **kwargs):
         Plot the fit results for each temperature.
-    overlay_fits(numpoints=None, vertical_offset=0, cmap='viridis', ax=ax):
+    overlay_fits(numpoints=None, vertical_offset=0, cmap='viridis', ax=ax, 
+                 data_kwargs=None, fit_kwargs=None):
         Plot raw data and fitted models for each temperature.
     fit_peak_simple():
         Perform a basic fit using a pseudo-Voigt peak shape, linear background, and no constraints.
-    plot_order_parameter(ax, **kwargs):
+    plot_order_parameter(ax, param_name='peakheight', **kwargs):
         Plot the temperature dependence of the peakheight parameter.
     print_fit_report():
         Print the fit report for each temperature.
@@ -188,6 +190,8 @@ class TempDependence:
         """
         for temperature in self.temperatures:
             self.scissors[temperature] = Scissors()
+            if temperature in self.datasets.keys():
+                self.scissors[temperature].set_data(self.datasets[temperature])
             self.linecutmodels[temperature] = LinecutModel()
 
     def set_data(self, temperature, data):
@@ -203,7 +207,7 @@ class TempDependence:
         """
         self.datasets[temperature] = data
 
-    def load_transforms(self, temperatures_list=None, print_tree=True, use_nxlink=False):
+    def load_transforms(self, temperatures_list=None, exclude_temperatures=None, print_tree=True, use_nxlink=False):
         """
         Load transform datasets (from nxrefine) based on temperature.
 
@@ -211,6 +215,9 @@ class TempDependence:
         ----------
         temperatures_list : list of int or None, optional
             List of temperatures to load. If None, all available temperatures are loaded.
+
+        exclude_temperatures : int, str, optional
+            Temperatures to skip. Applied after filtering with `temperatures_list`, if provided.
         
         print_tree : bool, optional
             Whether to print the data tree upon loading. Default True.
@@ -223,6 +230,10 @@ class TempDependence:
         # Convert all temperatures to strings
         if temperatures_list:
             temperatures_list = [str(t) for t in temperatures_list]
+        if exclude_temperatures:
+            if isinstance(exclude_temperatures, str):
+                exclude_temperatures = [exclude_temperatures]
+            exclude_temperatures = [str(t) for t in list(exclude_temperatures)]
 
         # Clear existing temperatures before loading files
         self.temperatures = []
@@ -237,7 +248,15 @@ class TempDependence:
                 # Identify temperature
                 temperature = match.group(1)
                 # print(f'Temperature = {temperature}')
-                if (temperatures_list is None) or (temperature in temperatures_list):
+                if temperatures_list is not None:
+                    incl_temp = temperature in temperatures_list
+                else:
+                    incl_temp = True
+                if exclude_temperatures is not None:
+                    not_excl_temp = temperature not in exclude_temperatures
+                else:
+                    not_excl_temp = True
+                if incl_temp and not_excl_temp:
                     # Prepare file to be loaded
                     self.temperatures.append(temperature)
                     items_to_load.append(item)
@@ -269,40 +288,38 @@ class TempDependence:
                       f" Error: {e}")
                 raise  # Re-raise the exception
 
-            # Initialize scissors object
-            self.scissors[self.temperatures[i]] = Scissors()
-            self.scissors[self.temperatures[i]].set_data(self.datasets[self.temperatures[i]])
+        self.initialize()
 
-            # Initialize linecutmodel object
-            self.linecutmodels[self.temperatures[i]] = LinecutModel()
-
-    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
+    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None, exclude_temperatures=None, print_tree=True):
         """
         Load datasets (CHESS format) from the specified folder.
 
         Parameters
         ----------
         file_ending : str, optional
-            The file extension of the datasets to be loaded. The default is 'hkli.nxs'.
-        temperatures_list : list of int or None, optional
-            The list of specific temperatures to load. If None, all available temperatures are
-            loaded. The default is None.
+            File extension of datasets to load. Default is 'hkli.nxs'.
+        temperatures_list : list of int or str, optional
+            Specific temperatures to load. If None, all temperatures are loaded.
+        exclude_temperatures : list of int or str, optional
+            Temperatures to skip. Applied after filtering with `temperatures_list`, if provided.
         print_tree : bool, optional
-            Whether to print the data tree upon loading. Default True.
+            If True, prints the NeXus tree structure for each file. Default is True.
         """
-        temperature_folders = []  # Empty list to store temperature folder names
-        for item in os.listdir(self.sample_directory):
-            try:
-                temperature_folders.append(int(item))  # If folder name can be int, add it
-            except ValueError:
-                pass  # Otherwise don't add it
-        temperature_folders.sort()  # Sort from low to high T
-        temperature_folders = [str(i) for i in temperature_folders]  # Convert to strings
-
-        self.temperatures = temperature_folders
 
         if temperatures_list is not None:
             self.temperatures = [str(t) for t in temperatures_list]
+        else:
+            self.temperatures = []  # Empty list to store temperature folder names
+            for item in os.listdir(self.sample_directory):
+                try:
+                    self.temperatures.append(int(item))  # If folder name can be int, add it
+                except ValueError:
+                    pass  # Otherwise don't add it
+            self.temperatures.sort()  # Sort from low to high T
+            self.temperatures = [str(i) for i in self.temperatures]  # Convert to strings
+            
+        if exclude_temperatures is not None:
+            [self.temperatures.remove(str(t)) for t in exclude_temperatures]
 
         # Load .nxs files
         for T in self.temperatures:
@@ -313,12 +330,7 @@ class TempDependence:
                     # Load dataset at each temperature
                     self.datasets[T] = load_data(filepath, print_tree)
 
-                    # Initialize scissors object at each temperature
-                    self.scissors[T] = Scissors()
-                    self.scissors[T].set_data(self.datasets[T])
-
-                    # Initialize linecutmodel object at each temperature
-                    self.linecutmodels[T] = LinecutModel()
+        self.initialize()
 
     def get_sample_directory(self):
         """
@@ -437,11 +449,16 @@ class TempDependence:
         # Get the Viridis colormap
         cmap = mpl.colormaps.get_cmap('viridis')
 
+        # Reverse zorder
+        zorder = 0
+
         for i, linecut in enumerate(self.linecuts.values()):
+            
             x_data = linecut[linecut.axes].nxdata
             y_data = linecut[linecut.signal].nxdata + i * vertical_offset
-            ax.plot(x_data, y_data, color=cmap(i / len(self.linecuts)), label=self.temperatures[i],
-                    **kwargs)
+            ax.plot(x_data, y_data, color=cmap(i / len(self.linecuts)), label=self.temperatures[i], 
+                    zorder=zorder, **kwargs)
+            zorder -= 1
 
         ax.set(xlabel=self.xlabel,
                ylabel=self.linecuts[self.temperatures[0]].signal)
@@ -704,7 +721,8 @@ class TempDependence:
                                   title=f"{T} K",
                                   **kwargs)
 
-    def overlay_fits(self, numpoints=None, vertical_offset=0, cmap='viridis', ax=None):
+    def overlay_fits(self, numpoints=None, vertical_offset=0, cmap='viridis', ax=None,
+                     data_kwargs=None, fit_kwargs=None):
         """
         Plot raw data and fitted models for each temperature with optional vertical offsets.
 
@@ -719,6 +737,11 @@ class TempDependence:
             Name of the matplotlib colormap used to distinguish different temperatures.
         ax : :class:`matplotlib.axes.Axes` or None, default=None
             Axis object to plot on. If None, a new figure and axis are created.
+        data_kwargs : dict
+            Keyword arguments to be passed to the data plot function.
+        fit_kwargs : dict
+            Keyword arguments to be passed to the fit plot function.
+
 
         The function:
         - Uses a colormap to assign unique colors to each temperature.
@@ -731,19 +754,24 @@ class TempDependence:
         # Create a figure and axes if an axis is not already provided
         _, ax = plt.subplots() if ax is None else (None, ax)
 
+        if data_kwargs is None:
+            data_kwargs = {}
+        if fit_kwargs is None:
+            fit_kwargs = {}
+
         # Generate a color palette for the various temperatures
         cmap = plt.get_cmap(cmap)
         colors = [cmap(i / len(self.temperatures)) for i, _ in enumerate(self.temperatures)]
 
         for i, lm in enumerate(self.linecutmodels.values()):
             # Plot the raw data
-            ax.plot(lm.x, lm.y + vertical_offset * i, '.', c=colors[i])
+            ax.plot(lm.x, lm.y + vertical_offset * i, '.', c=colors[i], **data_kwargs)
 
             # Evaluate the fit
             numpoints = len(lm.x) if numpoints is None else numpoints
             x_eval = np.linspace(lm.x.min(), lm.x.max(), numpoints)
             y_eval = lm.modelresult.eval(x=x_eval)
-            ax.plot(x_eval, y_eval + vertical_offset * i, '-', c=colors[i], label=self.temperatures[i])
+            ax.plot(x_eval, y_eval + vertical_offset * i, '-', c=colors[i], label=self.temperatures[i], **fit_kwargs)
 
         # Reverse legend entries to match top-to-bottom stacking
         handles, labels = ax.get_legend_handles_labels()
@@ -767,18 +795,19 @@ class TempDependence:
             linecutmodel.params['peakamplitude'].set(min=0)
             linecutmodel.fit()
 
-    def plot_order_parameter(self, ax=None, **kwargs):
+    def plot_order_parameter(self, param_name='peakheight', ax=None, **kwargs):
         """
         Plot the temperature dependence of the peak height (order parameter).
 
-        This method extracts the peak height from each temperature-dependent
-        line cut fit stored in `linecutmodels` and plots it as a function
-        of temperature using matplotlib.
+        This method extracts the values of a chosen parameter from each temperature-dependent
+        line cut fit stored in `linecutmodels` and plots it as a function of temperature.
 
         Parameters
         ----------
         ax : :class:`matplotlib.axes.Axes`, optional
             Axis object to plot on. If None, a new figure and axis are created.
+        param_name : str, optional
+            The name of the lmfit parameter to extract. Default is 'peakheight'.
         **kwargs
             Keyword arguments to be passed to the plot function.
 
@@ -810,7 +839,7 @@ class TempDependence:
             if self.linecutmodels[T].modelresult is None:
                 raise AttributeError("Model result is empty. Have you fit the data to a model?")
             
-            peakheights.append(self.linecutmodels[T].modelresult.params['peakheight'].value)
+            peakheights.append(self.linecutmodels[T].modelresult.params[param_name].value)
 
         # Plot the peakheights vs. temperature
         if ax is None:
@@ -818,7 +847,7 @@ class TempDependence:
         else:
             fig = ax.figure
         ax.plot(temperatures, peakheights, **kwargs)
-        ax.set(xlabel='$T$ (K)', ylabel='peakheight')
+        ax.set(xlabel='$T$ (K)', ylabel=param_name)
         return fig, ax
 
     def print_fit_report(self):

nxs_analysis_tools/datareduction.py

@@ -1,5 +1,6 @@
 """
-Reduces scattering data into 2D and 1D datasets.
+Tools for reducing data into 2D and 1D, and visualization functions for plotting and animating 
+data.
 """
 import os
 import io
@@ -14,12 +15,14 @@ from matplotlib import colors
 from matplotlib import patches
 from IPython.display import display, Markdown, HTML, Image
 from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXentry, nxsave
-from scipy import ndimage
+from scipy.ndimage import rotate
+
+from .lineartransformations import ShearTransformer
 
 
 # Specify items on which users are allowed to perform standalone imports
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
-           'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
+           'reciprocal_lattice_params', 'rotate_data',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
            'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'animate_slice_temp',
            'animate_slice_axis']
@@ -397,7 +400,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
 
     # If three-dimensional, demand sum_axis to reduce to two dimensions.
     if data.ndim == 3:
-        assert sum_axis is not None, "sum_axis must be specified when data.ndim == 3."
+        if sum_axis is None:
+            raise ValueError("sum_axis must be specified when data.ndim == 3.")
 
         if is_array:
             data = data.sum(axis=sum_axis)
@@ -501,17 +505,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     p = ax.pcolormesh(X.nxdata, Y.nxdata, data_arr, shading='auto', norm=norm, cmap=cmap, **kwargs)
 
     ## Transform data to new coordinate system if necessary
-    # Correct skew angle
-    skew_angle_adj = 90 - skew_angle
-    # Create blank 2D affine transformation
-    t = Affine2D()
-    # Scale y-axis to preserve norm while shearing
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
-    # Shear along x-axis
-    t += Affine2D().skew_deg(skew_angle_adj, 0)
-    # Return to original y-axis scaling
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
-    ## Correct for x-displacement after shearing
+    t = ShearTransformer(skew_angle)
+
     # If ylims provided, use those
     if ylim is not None:
         # Set ylims
@@ -521,8 +516,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     else:
         ymin, ymax = ax.get_ylim()
     # Use ylims to calculate translation (necessary to display axes in correct position)
-    p.set_transform(t
-                    + Affine2D().translate(-ymin * np.sin(skew_angle_adj * np.pi / 180), 0)
+    p.set_transform(t.t
+                    + Affine2D().translate(-ymin * np.sin(t.shear_angle * np.pi / 180), 0)
                     + ax.transData)
 
     # Set x limits
@@ -531,12 +526,12 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     else:
         xmin, xmax = ax.get_xlim()
     if skew_angle <= 90:
-        ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - skew_angle_adj) * np.pi / 180)))
+        ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - t.shear_angle) * np.pi / 180)))
     else:
-        ax.set(xlim=(xmin - (ymax - ymin) / np.tan((skew_angle_adj - 90) * np.pi / 180), xmax))
+        ax.set(xlim=(xmin - (ymax - ymin) / np.tan((t.shear_angle - 90) * np.pi / 180), xmax))
 
     # Correct aspect ratio for the x/y axes after transformation
-    ax.set(aspect=np.cos(skew_angle_adj * np.pi / 180))
+    ax.set(aspect=np.cos(t.shear_angle * np.pi / 180))
 
 
     # Automatically set tick locations, only if NXdata or if X,Y axes are provided for an array
@@ -568,7 +563,7 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
         line = ax.xaxis.get_majorticklines()[i]
         if i % 2:
             # Top ticks (translation here makes their direction="in")
-            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(t.shear_angle, 0))
             # This first method shifts the top ticks horizontally to match the skew angle.
             # This does not look good in all cases.
             # line.set_transform(Affine2D().translate((ymax-ymin)*np.sin(skew_angle*np.pi/180),0) +
@@ -578,7 +573,7 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
             line.set_transform(line.get_transform())  # This does nothing
         else:
             # Bottom ticks
-            m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().skew_deg(t.shear_angle, 0))
 
         line.set_marker(m)
 
@@ -586,9 +581,9 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
         m = MarkerStyle(2)
         line = ax.xaxis.get_minorticklines()[i]
         if i % 2:
-            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(t.shear_angle, 0))
         else:
-            m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
+            m._transform.set(Affine2D().skew_deg(t.shear_angle, 0))
 
         line.set_marker(m)
 
@@ -773,7 +768,7 @@ def animate_slice_axis(data, axis, axis_values, ax=None, interval=500, save_gif=
 
         if title:
             axis_label = data.axes[axis]
-            ax.set(title=f'${axis_label}$={parameter:{title_fmt}}')
+            ax.set(title=f'{axis_label}={parameter:{title_fmt}}')
 
     ani = animation.FuncAnimation(fig, update, frames=axis_values, interval=interval, repeat=False)
 
@@ -1232,9 +1227,9 @@ def convert_to_inverse_angstroms(data, lattice_params):
     return NXdata(new_data, (a_star, b_star, c_star))
 
 
-def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=False):
+def rotate_data(data, lattice_angle, rotation_angle, rotation_axis=None, printout=False):
     """
-    Rotates 3D data around a specified axis.
+    Rotates slices of data around the normal axis.
 
     Parameters
     ----------
@@ -1244,13 +1239,12 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         Angle between the two in-plane lattice axes in degrees.
     rotation_angle : float
         Angle of rotation in degrees.
-    rotation_axis : int
-        Axis of rotation (0, 1, or 2).
+    rotation_axis : int, optional
+        Axis of rotation (0, 1, or 2). Only necessary when data is three-dimensional.
     printout : bool, optional
-        Enables printout of rotation progress. If set to True, information
-        about each rotation slice will be printed to the console, indicating
-        the axis being rotated and the corresponding coordinate value.
-        Defaults to False.
+        Enables printout of rotation progress for three-dimensional data. If set to True,
+        information about each rotation slice will be printed to the console, indicating
+        the axis being rotated and the corresponding coordinate value. Defaults to False.
 
 
     Returns
@@ -1258,36 +1252,36 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
     rotated_data : :class:`nexusformat.nexus.NXdata`
         Rotated data as an NXdata object.
     """
+
+    if data.ndim == 3 and rotation_axis is None:
+        raise ValueError('rotation_axis must be specified for three-dimensional datasets.')
+    
+    if not((data.ndim == 2) or (data.ndim == 3)):
+        raise ValueError('Data must be 2 or 3 dimensional.')
+    
     # Define output array
     output_array = np.zeros(data.nxsignal.shape)
 
-    # Define shear transformation
-    skew_angle_adj = 90 - lattice_angle
-    t = Affine2D()
-    # Scale y-axis to preserve norm while shearing
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
-    # Shear along x-axis
-    t += Affine2D().skew_deg(skew_angle_adj, 0)
-    # Return to original y-axis scaling
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
-
     # Iterate over all layers perpendicular to the rotation axis
-    for i in range(len(data[data.axes[rotation_axis]])):
-        # Print progress
-        if printout:
-            print(f'\rRotating {data.axes[rotation_axis]}'
-                  f'={data[data.axes[rotation_axis]][i]}...                      ',
-                  end='', flush=True)
-
-        # Identify current slice
-        if rotation_axis == 0:
-            sliced_data = data[i, :, :]
-        elif rotation_axis == 1:
-            sliced_data = data[:, i, :]
-        elif rotation_axis == 2:
-            sliced_data = data[:, :, i]
-        else:
-            sliced_data = None
+    if data.ndim == 3:
+        num_slices = len(data.nxaxes[rotation_axis])
+    elif data.ndim == 2:
+        num_slices = 1
+    
+    for i in range(num_slices):
+        
+        if data.ndim == 3:
+            # Print progress
+            if printout:
+                print(f'\rRotating {data.axes[rotation_axis]}'
+                f'={data.nxaxes[rotation_axis][i]}...                      ',
+                end='', flush=True)
+            index = [slice(None)] * 3
+            index[rotation_axis] = i
+            sliced_data = data[tuple(index)]
+            
+        elif data.ndim == 2:
+            sliced_data = data
 
         # Add padding to avoid data cutoff during rotation
         p = Padder(sliced_data)
@@ -1295,76 +1289,38 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         counts = p.pad(padding)
         counts = p.padded[p.padded.signal]
 
-        # Perform shear operation
-        counts_skewed = ndimage.affine_transform(counts,
-                                                 t.inverted().get_matrix()[:2, :2],
-                                                 offset=[counts.shape[0] / 2
-                                                         * np.sin(skew_angle_adj * np.pi / 180),
-                                                         0],
-                                                 order=0,
-                                                 )
-        # Scale data based on skew angle
-        scale1 = np.cos(skew_angle_adj * np.pi / 180)
-        counts_scaled1 = ndimage.affine_transform(counts_skewed,
-                                                  Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
-                                                  offset=[(1 - scale1) * counts.shape[0] / 2, 0],
-                                                  order=0,
-                                                  )
-        # Scale data based on ratio of array dimensions
-        scale2 = counts.shape[0] / counts.shape[1]
-        counts_scaled2 = ndimage.affine_transform(counts_scaled1,
-                                                  Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
-                                                  offset=[(1 - scale2) * counts.shape[0] / 2, 0],
-                                                  order=0,
-                                                  )
+        # Skew data to match lattice angle
+        t = ShearTransformer(lattice_angle)
+        counts = t.apply(counts)
 
         # Perform rotation
-        counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
-
-        # Undo scaling 2
-        counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                    Affine2D().scale(
-                                                        scale2, 1
-                                                    ).inverted().get_matrix()[:2, :2],
-                                                    offset=[-(1 - scale2) * counts.shape[
-                                                        0] / 2 / scale2, 0],
-                                                    order=0,
-                                                    )
-        # Undo scaling 1
-        counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
-                                                    Affine2D().scale(
-                                                        scale1, 1
-                                                    ).inverted().get_matrix()[:2, :2],
-                                                    offset=[-(1 - scale1) * counts.shape[
-                                                        0] / 2 / scale1, 0],
-                                                    order=0,
-                                                    )
-        # Undo shear operation
-        counts_unskewed = ndimage.affine_transform(counts_unscaled1,
-                                                   t.get_matrix()[:2, :2],
-                                                   offset=[
-                                                       (-counts.shape[0] / 2
-                                                        * np.sin(skew_angle_adj * np.pi / 180)),
-                                                       0],
-                                                   order=0,
-                                                   )
+        counts = rotate(counts, rotation_angle, reshape=False, order=0)
+
+        # Undo skew transformation
+        counts = t.invert(counts)
+        
         # Remove padding
-        counts_unpadded = p.unpad(counts_unskewed)
-
-        # Write current slice
-        if rotation_axis == 0:
-            output_array[i, :, :] = counts_unpadded
-        elif rotation_axis == 1:
-            output_array[:, i, :] = counts_unpadded
-        elif rotation_axis == 2:
-            output_array[:, :, i] = counts_unpadded
-    print('\nDone.')
+        counts = p.unpad(counts)
+
+        # Write slice
+        if data.ndim == 3:
+            index = [slice(None)] * 3
+            index[rotation_axis] = i
+            output_array[tuple(index)] = counts
+        elif data.ndim == 2:
+            output_array = counts
+
+    print('\nRotation completed.')
+
     return NXdata(NXfield(output_array, name=p.padded.signal),
-                  (data.nxaxes[0], data.nxaxes[1], data.nxaxes[2]))
+                  ([axis for axis in data.nxaxes]))
+
 
 
 def rotate_data_2D(data, lattice_angle, rotation_angle):
     """
+    DEPRECATED: Use `rotate_data` instead.
+
     Rotates 2D data.
 
     Parameters
@@ -1376,86 +1332,20 @@ def rotate_data_2D(data, lattice_angle, rotation_angle):
     rotation_angle : float
         Angle of rotation in degrees.
 
-
     Returns
     -------
     rotated_data : :class:`nexusformat.nexus.NXdata`
         Rotated data as an NXdata object.
     """
+    warnings.warn(
+        "rotate_data_2D is deprecated and will be removed in a future release. "
+        "Use rotate_data instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
 
-    # Define transformation
-    skew_angle_adj = 90 - lattice_angle
-    t = Affine2D()
-    # Scale y-axis to preserve norm while shearing
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
-    # Shear along x-axis
-    t += Affine2D().skew_deg(skew_angle_adj, 0)
-    # Return to original y-axis scaling
-    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
-
-    # Add padding to avoid data cutoff during rotation
-    p = Padder(data)
-    padding = tuple(len(data[axis]) for axis in data.axes)
-    counts = p.pad(padding)
-    counts = p.padded[p.padded.signal]
-
-    # Perform shear operation
-    counts_skewed = ndimage.affine_transform(counts,
-                                             t.inverted().get_matrix()[:2, :2],
-                                             offset=[counts.shape[0] / 2
-                                                     * np.sin(skew_angle_adj * np.pi / 180), 0],
-                                             order=0,
-                                             )
-    # Scale data based on skew angle
-    scale1 = np.cos(skew_angle_adj * np.pi / 180)
-    counts_scaled1 = ndimage.affine_transform(counts_skewed,
-                                              Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
-                                              offset=[(1 - scale1) * counts.shape[0] / 2, 0],
-                                              order=0,
-                                              )
-    # Scale data based on ratio of array dimensions
-    scale2 = counts.shape[0] / counts.shape[1]
-    counts_scaled2 = ndimage.affine_transform(counts_scaled1,
-                                              Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
-                                              offset=[(1 - scale2) * counts.shape[0] / 2, 0],
-                                              order=0,
-                                              )
-    # Perform rotation
-    counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
-
-    # Undo scaling 2
-    counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                Affine2D().scale(
-                                                    scale2, 1
-                                                ).inverted().get_matrix()[:2, :2],
-                                                offset=[-(1 - scale2) * counts.shape[
-                                                    0] / 2 / scale2, 0],
-                                                order=0,
-                                                )
-    # Undo scaling 1
-    counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
-                                                Affine2D().scale(
-                                                    scale1, 1
-                                                ).inverted().get_matrix()[:2, :2],
-                                                offset=[-(1 - scale1) * counts.shape[
-                                                    0] / 2 / scale1, 0],
-                                                order=0,
-                                                )
-    # Undo shear operation
-    counts_unskewed = ndimage.affine_transform(counts_unscaled1,
-                                               t.get_matrix()[:2, :2],
-                                               offset=[
-                                                   (-counts.shape[0] / 2
-                                                    * np.sin(skew_angle_adj * np.pi / 180)),
-                                                   0],
-                                               order=0,
-                                               )
-    # Remove padding
-    counts_unpadded = p.unpad(counts_unskewed)
-
-    print('\nDone.')
-    return NXdata(NXfield(counts_unpadded, name=p.padded.signal),
-                  (data.nxaxes[0], data.nxaxes[1]))
+    # Call the new general function
+    return rotate_data(data, lattice_angle=lattice_angle, rotation_angle=rotation_angle)
 
 
 class Padder:

nxs_analysis_tools/datasets.py

@@ -0,0 +1,108 @@
+import os
+import pooch
+
+GOODBOY = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/cubic"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-cubic/main/data/",
+    registry={
+        "cubic_15.nxs": None,
+        "15/transform.nxs": None,
+        "cubic_25.nxs": None,
+        "25/transform.nxs": None,
+        "cubic_35.nxs": None,
+        "35/transform.nxs": None,
+        "cubic_45.nxs": None,
+        "45/transform.nxs": None,
+        "cubic_55.nxs": None,
+        "55/transform.nxs": None,
+        "cubic_65.nxs": None,
+        "65/transform.nxs": None,
+        "cubic_75.nxs": None,
+        "75/transform.nxs": None,
+        "cubic_80.nxs": None,
+        "80/transform.nxs": None,
+        "cubic_104.nxs": None,
+        "104/transform.nxs": None,
+        "cubic_128.nxs": None,
+        "128/transform.nxs": None,
+        "cubic_153.nxs": None,
+        "153/transform.nxs": None,
+        "cubic_177.nxs": None,
+        "177/transform.nxs": None,
+        "cubic_202.nxs": None,
+        "202/transform.nxs": None,
+        "cubic_226.nxs": None,
+        "226/transform.nxs": None,
+        "cubic_251.nxs": None,
+        "251/transform.nxs": None,
+        "cubic_275.nxs": None,
+        "275/transform.nxs": None,
+        "cubic_300.nxs": None,
+        "300/transform.nxs": None,
+    }
+)
+
+def fetch_cubic(temperatures=None):
+    """
+    Load the cubic dataset.
+    """
+    fnames = []
+    temperatures = [15, 25, 35, 45, 55, 65, 75, 80, 104, 128,
+                    153, 177, 202, 226, 251, 275, 300] if temperatures is None else temperatures
+    for T in temperatures:
+        fnames.append(GOODBOY.fetch(f"cubic_{T}.nxs"))
+        fnames.append(GOODBOY.fetch(f"{T}/transform.nxs"))
+    return fnames
+
+def cubic(temperatures=None):
+    fnames = fetch_cubic(temperatures)
+    dirname = os.path.dirname(fnames[0])
+    return dirname
+
+POOCH = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/hexagonal"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-hexagonal/main/data/",
+    registry={
+        "hexagonal_15.nxs": "850d666d6fb0c7bbf7f7159fed952fbd53355c3c0bfb40410874d3918a3cca49",
+        "15/transform.nxs": "45c089be295e0a5b927e963540a90b41f567edb75f283811dbc6bb4a26f2fba5",
+        "hexagonal_300.nxs": "c6a9ff704d1e42d9576d007a92a333f529e3ddf605e3f76a82ff15557b7d4a43",
+        "300/transform.nxs": "e665ba59debe8e60c90c3181e2fb1ebbce668a3d3918a89a6bf31e3563ebf32e",
+    }
+)
+
+def fetch_hexagonal(temperatures=None):
+    """
+    Load the hexagonal dataset.
+    """
+    fnames = []
+    temperatures = [15, 300] if temperatures is None else temperatures
+    for T in temperatures:
+        fnames.append(POOCH.fetch(f"hexagonal_{T}.nxs"))
+        fnames.append(POOCH.fetch(f"{T}/transform.nxs"))
+    return fnames
+
+def hexagonal(temperatures=None):
+    fnames = fetch_hexagonal(temperatures)
+    dirname = os.path.dirname(fnames[0])
+    return dirname
+
+BONES = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/vacancies"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-vacancies/main/",
+    registry={
+        "vacancies.nxs": "39eaf8df84a0dbcacbe6ce7c6017da4da578fbf68a6218ee18ade3953c26efb5",
+        "fft.nxs": "c81178eda0ec843502935f29fcb2b0b878f7413e461612c731d37ea9e5e414a9",
+    }
+)
+
+def vacancies():
+    """
+    Load the vacancies dataset.
+    """
+    return BONES.fetch(f"vacancies.nxs")
+
+def vacanciesfft():
+    """
+    Load the vacancies dataset.
+    """
+    return BONES.fetch(f"fft.nxs")

nxs_analysis_tools/lineartransformations.py

@@ -0,0 +1,51 @@
+import numpy as np
+from scipy.ndimage import affine_transform
+from matplotlib.transforms import Affine2D
+
+def shear_transformation(angle):
+    # Define shear transformation
+    t = Affine2D()
+
+    # Scale y-axis to preserve norm while shearing
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180))
+
+    # Shear along x-axis
+    t += Affine2D().skew_deg(angle, 0)
+
+    # Return to original y-axis scaling
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180)).inverted()
+
+    return t
+
+class ShearTransformer():
+    def __init__(self, angle):
+        self.shear_angle = 90 - angle
+        self.t = shear_transformation(self.shear_angle)
+        self.scale = np.cos(self.shear_angle * np.pi / 180)
+
+    def apply(self, image):
+        # Perform shear operation
+        image_skewed = affine_transform(image, self.t.inverted().get_matrix()[:2, :2], 
+                                        offset=[image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180), 0], 
+                                        order=0
+                                        )
+        # Scale data based on skew angle
+        image_scaled = affine_transform(image_skewed, Affine2D().scale(self.scale, 1).get_matrix()[:2, :2],
+                                        offset=[(1 - self.scale) * image.shape[0] / 2, 0],
+                                        order=0
+                                        )
+        return image_scaled
+
+    def invert(self, image):
+
+        # Undo scaling
+        image_unscaled = affine_transform(image, Affine2D().scale(self.scale, 1).inverted().get_matrix()[:2, :2],
+                                          offset=[-(1 - self.scale) * image.shape[0] / 2 / self.scale, 0],
+                                          order=0
+                                          )
+        # Undo shear operation
+        image_unskewed = affine_transform(image_unscaled, self.t.get_matrix()[:2, :2],
+                                          offset=[(-image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180)), 0],
+                                          order=0
+                                          )
+        return image_unskewed

nxs_analysis_tools/pairdistribution.py

@@ -5,7 +5,7 @@ import time
 import os
 import gc
 import math
-from scipy import ndimage
+from scipy.ndimage import rotate, affine_transform
 import scipy
 import matplotlib.pyplot as plt
 from matplotlib.transforms import Affine2D
@@ -15,6 +15,7 @@ from astropy.convolution import Kernel, convolve_fft
 import pyfftw
 from .datareduction import plot_slice, reciprocal_lattice_params, Padder, \
     array_to_nxdata
+from .lineartransformations import ShearTransformer
 
 __all__ = ['Symmetrizer2D', 'Symmetrizer3D', 'Puncher', 'Interpolator',
            'fourier_transform_nxdata', 'Gaussian3DKernel', 'DeltaPDF',
@@ -37,9 +38,6 @@ class Symmetrizer2D:
     symmetrized : NXdata or None
         The symmetrized dataset after applying the symmetrization operations.
         Default is None until symmetrization is performed.
-    wedges : NXdata or None
-        The wedges extracted from the dataset based on the angular limits.
-        Default is None until symmetrization is performed.
     rotations : int or None
         The number of rotations needed to reconstruct the full dataset from
         a single wedge. Default is None until parameters are set.
@@ -93,7 +91,6 @@ class Symmetrizer2D:
         """
         self.mirror_axis = None
         self.symmetrized = None
-        self.wedges = None
         self.rotations = None
         self.transform = None
         self.mirror = None
@@ -129,16 +126,8 @@ class Symmetrizer2D:
         self.mirror = mirror
         self.mirror_axis = mirror_axis
 
-        # Define Transformation
-        skew_angle_adj = 90 - lattice_angle
-        t = Affine2D()
-        # Scale y-axis to preserve norm while shearing
-        t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
-        # Shear along x-axis
-        t += Affine2D().skew_deg(skew_angle_adj, 0)
-        # Return to original y-axis scaling
-        t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
-        self.transform = t
+        self.transformer = ShearTransformer(lattice_angle)
+        self.transform = self.transformer.t
 
         # Calculate number of rotations needed to reconstruct the dataset
         if mirror:
@@ -172,7 +161,6 @@ class Symmetrizer2D:
         theta_max = self.theta_max
         mirror = self.mirror
         mirror_axis = self.mirror_axis
-        t = self.transform
         rotations = self.rotations
 
         # Pad the dataset so that rotations don't get cutoff if they extend
@@ -191,37 +179,9 @@ class Symmetrizer2D:
         symmetrization_mask = np.logical_and(theta >= theta_min * np.pi / 180,
                                              theta <= theta_max * np.pi / 180)
 
-        # Define signal to be transformed
-        counts = symmetrization_mask
-
-        # Scale and skew counts
-        skew_angle_adj = 90 - self.skew_angle
-
-        scale2 = 1 # q1.max()/q2.max() # TODO: Need to double check this
-        counts_unscaled2 = ndimage.affine_transform(counts,
-                                                    Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
-                                                    offset=[-(1 - scale2) * counts.shape[
-                                                        0] / 2 / scale2, 0],
-                                                    order=0,
-                                                    )
-
-        scale1 = np.cos(skew_angle_adj * np.pi / 180)
-        counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
-                                                    Affine2D().scale(scale1, 1).inverted().get_matrix()[:2, :2],
-                                                    offset=[-(1 - scale1) * counts.shape[
-                                                        0] / 2 / scale1, 0],
-                                                    order=0,
-                                                    )
-
-        mask = ndimage.affine_transform(counts_unscaled1,
-                                        t.get_matrix()[:2, :2],
-                                        offset=[-counts.shape[0] / 2
-                                                * np.sin(skew_angle_adj * np.pi / 180), 0],
-                                        order=0,
-                                        )
-
-        # Convert mask to nxdata
-        mask = array_to_nxdata(mask, data_padded)
+        # Bring mask from skewed basis to data array basis
+        mask = array_to_nxdata(self.transformer.invert(symmetrization_mask), data_padded)
+
 
         # Save mask for user interaction
         self.symmetrization_mask = p.unpad(mask)
@@ -235,84 +195,49 @@ class Symmetrizer2D:
         # Convert wedge back to array for further transformations
         wedge = wedge[data.signal].nxdata
 
-        # Define signal to be transformed
-        counts = wedge
+        # Bring wedge from data array basis to skewed basis for reconstruction
+        wedge = self.transformer.apply(wedge)
 
-        # Scale and skew counts
-        skew_angle_adj = 90 - self.skew_angle
-        counts_skew = ndimage.affine_transform(counts,
-                                               t.inverted().get_matrix()[:2, :2],
-                                               offset=[counts.shape[0] / 2
-                                                       * np.sin(skew_angle_adj * np.pi / 180), 0],
-                                               order=0,
-                                               )
-        scale1 = np.cos(skew_angle_adj * np.pi / 180)
-        wedge = ndimage.affine_transform(counts_skew,
-                                         Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
-                                         offset=[(1 - scale1) * counts.shape[0] / 2, 0],
-                                         order=0,
-                                         )
-
-        scale2 = counts.shape[0]/counts.shape[1]
-        wedge = ndimage.affine_transform(wedge,
-                                         Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
-                                         offset=[(1 - scale2) * counts.shape[0] / 2, 0],
+        # Apply additional scaling before rotations
+        scale = wedge.shape[0]/wedge.shape[1]
+        wedge = affine_transform(wedge,
+                                         Affine2D().scale(scale, 1).get_matrix()[:2, :2],
+                                         offset=[(1 - scale) * wedge.shape[0] / 2, 0],
                                          order=0,
                                          )
 
         # Reconstruct full dataset from wedge
-        reconstructed = np.zeros(counts.shape)
+        reconstructed = np.zeros(wedge.shape)
+
         for _ in range(0, rotations):
-            # The following are attempts to combine images with minimal overlapping pixels
             reconstructed += wedge
-            # reconstructed = np.where(reconstructed == 0, reconstructed + wedge, reconstructed)
-
-            wedge = ndimage.rotate(wedge, 360 / rotations, reshape=False, order=0)
-
-        # self.rotated_only = NXdata(NXfield(reconstructed, name=data.signal),
-        #                            (q1, q2))
+            wedge = rotate(wedge, 360 / rotations, reshape=False, order=0)
 
         if mirror:
-            # The following are attempts to combine images with minimal overlapping pixels
             reconstructed = np.where(reconstructed == 0,
                                      reconstructed + np.flip(reconstructed, axis=mirror_axis),
                                      reconstructed)
-            # reconstructed += np.flip(reconstructed, axis=0)
-
-        # self.rotated_and_mirrored = NXdata(NXfield(reconstructed, name=data.signal),
-        #                                    (q1, q2))
+            
 
-        reconstructed = ndimage.affine_transform(reconstructed,
+        # Undo scaling transformation
+        reconstructed = affine_transform(reconstructed,
                                                  Affine2D().scale(
-                                                     scale2, 1
+                                                     scale, 1
                                                  ).inverted().get_matrix()[:2, :2],
-                                                 offset=[-(1 - scale2) * counts.shape[
-                                                     0] / 2 / scale2, 0],
-                                                 order=0,
-                                                 )
-        reconstructed = ndimage.affine_transform(reconstructed,
-                                                 Affine2D().scale(
-                                                     scale1, 1
-                                                 ).inverted().get_matrix()[:2, :2],
-                                                 offset=[-(1 - scale1) * counts.shape[
-                                                     0] / 2 / scale1, 0],
-                                                 order=0,
-                                                 )
-        reconstructed = ndimage.affine_transform(reconstructed,
-                                                 t.get_matrix()[:2, :2],
-                                                 offset=[(-counts.shape[0] / 2
-                                                          * np.sin(skew_angle_adj * np.pi / 180)),
-                                                         0],
+                                                 offset=[-(1 - scale) * wedge.shape[
+                                                     0] / 2 / scale, 0],
                                                  order=0,
                                                  )
+        
+        reconstructed = self.transformer.invert(reconstructed)
 
-        reconstructed_unpadded = p.unpad(reconstructed)
+        reconstructed = p.unpad(reconstructed)
 
         # Fix any overlapping pixels by truncating counts to max
-        reconstructed_unpadded[reconstructed_unpadded > data[data.signal].nxdata.max()] \
+        reconstructed[reconstructed > data[data.signal].nxdata.max()] \
             = data[data.signal].nxdata.max()
 
-        symmetrized = NXdata(NXfield(reconstructed_unpadded, name=data.signal),
+        symmetrized = NXdata(NXfield(reconstructed, name=data.signal),
                              (data[data.axes[0]],
                               data[data.axes[1]]))
 
@@ -349,12 +274,11 @@ class Symmetrizer2D:
         - Subplot 3: The wedge slice used for reconstruction of the full symmetrized dataset.
         - Subplot 4: The symmetrized dataset.
 
-        Example usage:
-        ```
-        s = Symmetrizer2D()
-        s.set_parameters(theta_min, theta_max, skew_angle, mirror)
-        s.test(data)
-        ```
+        Example
+        -------
+        >>> s = Symmetrizer2D()
+        >>> s.set_parameters(theta_min, theta_max, skew_angle, mirror)
+        >>> s.test(data)
         """
         s = self
         symm_test = s.symmetrize_2d(data)
@@ -400,7 +324,8 @@ class Symmetrizer3D:
             The input 3D dataset to be symmetrized.
         """
 
-        assert data is not None, "Symmetrizer3D requires a 3D NXdata object for initialization."
+        if data is None:
+            raise ValueError("Symmetrizer3D requires a 3D NXdata object for initialization.")
 
         self.a, self.b, self.c, self.al, self.be, self.ga = [None] * 6
         self.a_star, self.b_star, self.c_star, self.al_star, self.be_star, self.ga_star = [None] * 6

{nxs_analysis_tools-0.1.9.dist-info → nxs_analysis_tools-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.1.9
+Version: 0.1.11
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License-Expression: MIT
@@ -14,11 +14,10 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.10.0
@@ -46,6 +45,7 @@ Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
 Requires-Dist: sphinxext-opengraph>=0.6.3; extra == "dev"
 Requires-Dist: twine>=4.0.1; extra == "dev"
+Requires-Dist: pooch>=1.8.2; extra == "dev"
 Dynamic: license-file
 
 # nxs-analysis-tools
@@ -56,7 +56,7 @@ Dynamic: license-file
 
 ## Overview
 
-nxs-analysis-tools provides a suite of tools for slicing (2D), cutting (1D), and transforming (_e.g._, symmetrization, interpolation, delta-PDF) nexus format (.nxs) scattering data.
+nxs-analysis-tools provides a suite of tools for performing slices (2D), cuts (1D), and transformations (_e.g._, symmetrization, interpolation, delta-PDF) on nexus format (.nxs) scattering data.
 
 View the documentation [here](https://nxs-analysis-tools.readthedocs.io/en/stable/).
 
@@ -76,4 +76,14 @@ git clone https://github.com/stevenjgomez/nxs-analysis-tools.git
 
 ## License
 
-This project is licensed under the MIT License.
+This project is licensed under the MIT License. If you find the nxs-analysis-tools package useful in your scientific publications, please cite the relevant DOI.
+
+To cite the most recent version, use:
+
+[![DOI](https://zenodo.org/badge/644189683.svg)](https://doi.org/10.5281/zenodo.15186359)
+
+To cite all versions, use:
+
+```
+10.5281/zenodo.15186359
+```

nxs_analysis_tools-0.1.11.dist-info/RECORD

@@ -0,0 +1,13 @@
+_meta/__init__.py,sha256=O-Csyugy_6ZYl7nR_6FgU1-D1-64dSBtRSRzDF1aiq4,347
+nxs_analysis_tools/__init__.py,sha256=Gs61l3FrgmhVRv77oqz58W6vmxFhNARfcioYA0FZbqU,604
+nxs_analysis_tools/chess.py,sha256=_gFkLZnoYSCOKPZHm0b1CileCveHJpOszLufeg4QKFg,34086
+nxs_analysis_tools/datareduction.py,sha256=Ky8Q5izEXmOUj3OKOlvZ8A-YeKRdAOD22luggiZtLoY,52181
+nxs_analysis_tools/datasets.py,sha256=KnJBdxuCV7n2Q6MOM0Cv5-Dq6x1hvrrEXIc3Jn7Xsos,3497
+nxs_analysis_tools/fitting.py,sha256=kRMhjObetGqmZ5-Jk1OHKGrXW4qI4D37s8VeC2ygJV8,10275
+nxs_analysis_tools/lineartransformations.py,sha256=-Ce2RzcRcUgg8_kM1o0kO9lOpS_nC2AxRyZTUA1tAe8,2144
+nxs_analysis_tools/pairdistribution.py,sha256=u4WyOfK_nBX78QJr7QO8QWGKV9bH_sBWtdzVaqs2wWo,61238
+nxs_analysis_tools-0.1.11.dist-info/licenses/LICENSE,sha256=bE6FnYixueAGAnEfUuumbkSeMgdBguAAkheVgjv47Jo,1086
+nxs_analysis_tools-0.1.11.dist-info/METADATA,sha256=sdphx8gVih0ZeQOPEHw4_R-sS6D6XlQNZWc6JOxAB5g,3493
+nxs_analysis_tools-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nxs_analysis_tools-0.1.11.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
+nxs_analysis_tools-0.1.11.dist-info/RECORD,,

nxs_analysis_tools-0.1.9.dist-info/RECORD

@@ -1,11 +0,0 @@
-_meta/__init__.py,sha256=_6YTHnZTh1hFtcZstSxlck37JDEvSrKKPTDaeiNi2mc,346
-nxs_analysis_tools/__init__.py,sha256=lutfLk7oBaMpKq2G2hf6V59SNqAhzSUyKLXGwTI_iDg,622
-nxs_analysis_tools/chess.py,sha256=mTl3-hfKG6xUtuzqWJa63t1qg975Iv8ND6C6B1dxPio,32699
-nxs_analysis_tools/datareduction.py,sha256=PMSV-_f66NK0Sf70z_xp7eQqcOe5krRkbQdVo6mTX3E,59233
-nxs_analysis_tools/fitting.py,sha256=kRMhjObetGqmZ5-Jk1OHKGrXW4qI4D37s8VeC2ygJV8,10275
-nxs_analysis_tools/pairdistribution.py,sha256=BDJdPiQ-XEk8vZKiFQnCotaWeS5cDDGqmSyhzC3fwrQ,65586
-nxs_analysis_tools-0.1.9.dist-info/licenses/LICENSE,sha256=bE6FnYixueAGAnEfUuumbkSeMgdBguAAkheVgjv47Jo,1086
-nxs_analysis_tools-0.1.9.dist-info/METADATA,sha256=Z0pCGXvg06-cD0iZhuIzMtam_j8EAJGRL3K3NAgNiCI,3180
-nxs_analysis_tools-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nxs_analysis_tools-0.1.9.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
-nxs_analysis_tools-0.1.9.dist-info/RECORD,,