nxs-analysis-tools 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

nxs_analysis_tools/datareduction.py

@@ -14,18 +14,20 @@ from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXent
 from scipy import ndimage
 
 # Specify items on which users are allowed to perform standalone imports
-__all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors', 'reciprocal_lattice_params', 'rotate_data',
+__all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
+           'reciprocal_lattice_params', 'rotate_data',
            'array_to_nxdata', 'Padder']
 
 
 def load_data(path):
     """
-    Load data from a specified path.
+    Load data from a NeXus file at a specified path. It is assumed that the data follows the CHESS
+    file structure (i.e., root/entry/data/counts, etc.).
 
     Parameters
     ----------
     path : str
-        The path to the data file.
+        The path to the NeXus data file.
 
     Returns
     -------
@@ -45,11 +47,11 @@ def load_data(path):
 
 def load_transform(path):
     """
-    Load nxrefine-transformed data from a specified path.
+    Load data obtained from nxrefine output from a specified path.
 
     Parameters
     ----------
-    path : str The path to the data file.
+    path : str The path to the transform data file.
 
     Returns
     -------
@@ -62,7 +64,8 @@ def load_transform(path):
 
 def array_to_nxdata(array, data_template, signal_name='counts'):
     """
-    Create an NXdata object from an input array and an NXdata template, with an optional signal name.
+    Create an NXdata object from an input array and an NXdata template,
+    with an optional signal name.
 
     Parameters
     ----------
@@ -70,7 +73,8 @@ def array_to_nxdata(array, data_template, signal_name='counts'):
         The data array to be included in the NXdata object.
 
     data_template : NXdata
-        An NXdata object serving as a template, which provides information about axes and other metadata.
+        An NXdata object serving as a template, which provides information
+        about axes and other metadata.
 
     signal_name : str, optional
         The name of the signal within the NXdata object. If not provided,
@@ -79,86 +83,107 @@ def array_to_nxdata(array, data_template, signal_name='counts'):
     Returns
     -------
     NXdata
-        An NXdata object containing the input data array and associated axes based on the template.
+        An NXdata object containing the input data array and associated axes
+        based on the template.
     """
     d = data_template
-    return NXdata(NXfield(array, name=signal_name), tuple([d[d.axes[i]] for i in range(len(d.axes))]))
+    return NXdata(NXfield(array, name=signal_name),
+                  tuple(d[d.axes[i]] for i in range(len(d.axes))))
 
 
-def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew_angle=90,
-               ax=None, xlim=None, ylim=None, xticks=None, yticks=None, cbar=True, logscale=False,
-               symlogscale=False, cmap='viridis', linthresh=1, title=None, mdheading=None, cbartitle=None,
+def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
+               skew_angle=90, ax=None, xlim=None, ylim=None,
+               xticks=None, yticks=None, cbar=True, logscale=False,
+               symlogscale=False, cmap='viridis', linthresh=1,
+               title=None, mdheading=None, cbartitle=None,
                **kwargs):
     """
+    Plot a 2D slice of the provided dataset, with optional transformations
+    and customizations.
+
     Parameters
     ----------
-    data : :class:`nexusformat.nexus.NXdata` object or ndarray
-        The NXdata object containing the dataset to plot.
+    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. Default is first axis of `data`.
+        The X axis values. If None, a default range from 0 to the number of
+         columns in `data` is used.
 
     Y : NXfield, optional
-        The y axis values. Default is second axis of `data`.
+        The Y axis values. If None, a default range from 0 to the number of
+         rows in `data` is used.
 
     transpose : bool, optional
-        If True, tranpose the dataset and its axes before plotting. Default is False.
+        If True, transpose the dataset and its axes before plotting.
+        Default is False.
 
     vmin : float, optional
-        The minimum value to plot in the dataset.
-        If not provided, the minimum of the dataset will be used.
+        The minimum value for the color scale. If not provided, the minimum
+         value of the dataset is used.
 
     vmax : float, optional
-        The maximum value to plot in the dataset.
-        If not provided, the maximum of the dataset will be used.
+        The maximum value for the color scale. If not provided, the maximum
+         value of the dataset is used.
 
     skew_angle : float, optional
-        The angle to shear the plot in degrees. Defaults to 90 degrees (no skewing).
+        The angle in degrees to shear the plot. Default is 90 degrees (no skew).
 
     ax : matplotlib.axes.Axes, optional
-        An optional axis object to plot the heatmap onto.
+        The `matplotlib` axis to plot on. If None, a new figure and axis will
+         be created.
 
     xlim : tuple, optional
-        The limits of the x-axis. If not provided, the limits will be automatically set.
+        The limits for the x-axis. If None, the limits are set automatically
+         based on the data.
 
     ylim : tuple, optional
-        The limits of the y-axis. If not provided, the limits will be automatically set.
+        The limits for the y-axis. If None, the limits are set automatically
+         based on the data.
 
-    xticks : float, optional
-        The major tick interval for the x-axis.
-        If not provided, the function will use a default minor tick interval of 1.
+    xticks : float or list of float, optional
+        The major tick interval or specific tick locations for the x-axis.
+         Default is to use a minor tick interval of 1.
 
-    yticks : float, optional
-        The major tick interval for the y-axis.
-        If not provided, the function will use a default minor tick interval of 1.
+    yticks : float or list of float, optional
+        The major tick interval or specific tick locations for the y-axis.
+        Default is to use a minor tick interval of 1.
 
     cbar : bool, optional
-        Whether to include a colorbar in the plot. Defaults to True.
+        Whether to include a colorbar. Default is True.
 
     logscale : bool, optional
-        Whether to use a logarithmic color scale. Defaults to False.
+        Whether to use a logarithmic color scale. Default is False.
 
     symlogscale : bool, optional
-        Whether to use a symmetrical logarithmic color scale. Defaults to False.
+        Whether to use a symmetrical logarithmic color scale. Default is False.
 
     cmap : str or Colormap, optional
-        The color map to use. Defaults to 'viridis'.
+        The colormap to use for the plot. Default is 'viridis'.
 
     linthresh : float, optional
-        The linear threshold for the symmetrical logarithmic color scale. Defaults to 1.
+        The linear threshold for symmetrical logarithmic scaling. Default is 1.
+
+    title : str, optional
+        The title for the plot. If None, no title is set.
 
     mdheading : str, optional
-        A string containing the Markdown heading for the plot. Default `None`.
+        A Markdown heading to display above the plot. If 'None' or not provided,
+         no heading is displayed.
+
+    cbartitle : str, optional
+        The title for the colorbar. If None, the colorbar label will be set to
+         the name of the signal.
+
+    **kwargs
+        Additional keyword arguments passed to `pcolormesh`.
 
     Returns
     -------
     p : :class:`matplotlib.collections.QuadMesh`
-
-        A :class:`matplotlib.collections.QuadMesh` object, to mimick behavior of
-        :class:`matplotlib.pyplot.pcolormesh`.
-
+        The `matplotlib` QuadMesh object representing the plotted data.
     """
-    if type(data) == np.ndarray:
+    if isinstance(data, np.ndarray):
         if X is None:
             X = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='x')
         if Y is None:
@@ -168,7 +193,7 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
             data = data.transpose()
         data = NXdata(NXfield(data, name='value'), (X, Y))
         data_arr = data
-    elif type(data) == NXdata or type(data) == NXfield:
+    elif isinstance(data, (NXdata, NXfield)):
         if X is None:
             X = data[data.axes[0]]
         if Y is None:
@@ -178,7 +203,8 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
             data = data.transpose()
         data_arr = data[data.signal].nxdata.transpose()
     else:
-        raise TypeError(f"Unexpected data type: {type(data)}. Supported types are np.ndarray and NXdata.")
+        raise TypeError(f"Unexpected data type: {type(data)}. "
+                        f"Supported types are np.ndarray and NXdata.")
 
     # Display Markdown heading
     if mdheading is None:
@@ -190,7 +216,6 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
 
     # Inherit axes if user provides some
     if ax is not None:
-        ax = ax
         fig = ax.get_figure()
     # Otherwise set up some default axes
     else:
@@ -235,7 +260,9 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
     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) + ax.transData)
+    p.set_transform(t
+                    + Affine2D().translate(-ymin * np.sin(skew_angle_adj * np.pi / 180), 0)
+                    + ax.transData)
 
     # Set x limits
     if xlim is not None:
@@ -332,32 +359,32 @@ class Scissors:
         Extents of the window for integration along each axis.
     axis : int or None
         Axis along which to perform the integration.
-    data_cut : ndarray or None
+    integration_volume : :class:`nexusformat.nexus.NXdata` or None
         Data array after applying the integration window.
     integrated_axes : tuple or None
         Indices of axes that were integrated.
     linecut : :class:`nexusformat.nexus.NXdata` or None
         1D linecut data after integration.
-    window_plane_slice_obj : list or None
+    integration_window : tuple or None
         Slice object representing the integration window in the data array.
 
     Methods
     -------
     set_data(data)
-        Set the input :class:`nexusformat.nexus.NXdata`
+        Set the input :class:`nexusformat.nexus.NXdata`.
     get_data()
         Get the input :class:`nexusformat.nexus.NXdata`.
     set_center(center)
         Set the central coordinate for the linecut.
-    set_window(window)
+    set_window(window, axis=None, verbose=False)
         Set the extents of the integration window.
     get_window()
         Get the extents of the integration window.
-    cut_data(axis=None)
+    cut_data(center=None, window=None, axis=None, verbose=False)
         Reduce data to a 1D linecut using the integration window.
-    show_integration_window(label=None)
+    highlight_integration_window(data=None, label=None, highlight_color='red', **kwargs)
         Plot the integration window highlighted on a 2D heatmap of the full dataset.
-    plot_window()
+    plot_integration_window(**kwargs)
         Plot a 2D heatmap of the integration window data.
     """
 
@@ -378,8 +405,8 @@ class Scissors:
         """
 
         self.data = data
-        self.center = tuple([float(i) for i in center]) if center is not None else None
-        self.window = tuple([float(i) for i in window]) if window is not None else None
+        self.center = tuple(float(i) for i in center) if center is not None else None
+        self.window = tuple(float(i) for i in window) if window is not None else None
         self.axis = axis
 
         self.integration_volume = None
@@ -418,9 +445,9 @@ class Scissors:
         center : tuple
             Central coordinate around which to perform the linecut.
         """
-        self.center = tuple([float(i) for i in center]) if center is not None else None
+        self.center = tuple(float(i) for i in center) if center is not None else None
 
-    def set_window(self, window):
+    def set_window(self, window, axis=None, verbose=False):
         """
         Set the extents of the integration window.
 
@@ -428,16 +455,25 @@ class Scissors:
         ----------
         window : tuple
             Extents of the window for integration along each axis.
+        axis : int or None, optional
+            The axis along which to perform the linecut. If not specified, the value from the
+            object's attribute will be used.
+        verbose : bool, optional
+            Enables printout of linecut axis and integrated axes. Default False.
+
         """
-        self.window = tuple([float(i) for i in window]) if window is not None else None
+        self.window = tuple(float(i) for i in window) if window is not None else None
 
         # Determine the axis for integration
-        self.axis = window.index(max(window))
-        print("Linecut axis: " + str(self.data.axes[self.axis]))
+        self.axis = window.index(max(window)) if axis is None else axis
 
         # Determine the integrated axes (axes other than the integration axis)
         self.integrated_axes = tuple(i for i in range(self.data.ndim) if i != self.axis)
-        print("Integrated axes: " + str([self.data.axes[axis] for axis in self.integrated_axes]))
+
+        if verbose:
+            print("Linecut axis: " + str(self.data.axes[self.axis]))
+            print("Integrated axes: " + str([self.data.axes[axis]
+                                             for axis in self.integrated_axes]))
 
     def get_window(self):
         """
@@ -450,13 +486,13 @@ class Scissors:
         """
         return self.window
 
-    def cut_data(self, center=None, window=None, axis=None):
+    def cut_data(self, center=None, window=None, axis=None, verbose=False):
         """
-        Reduces data to a 1D linecut with integration extents specified by the window about a central
-        coordinate.
+        Reduces data to a 1D linecut with integration extents specified by the
+        window about a central coordinate.
 
         Parameters
-        -----------
+        ----------
         center : float or None, optional
             Central coordinate for the linecut. If not specified, the value from the object's
             attribute will be used.
@@ -466,11 +502,14 @@ class Scissors:
         axis : int or None, optional
             The axis along which to perform the linecut. If not specified, the value from the
             object's attribute will be used.
+        verbose : bool
+            Enables printout of linecut axis and integrated axes. Default False.
 
         Returns
-        --------
+        -------
         integrated_data : :class:`nexusformat.nexus.NXdata`
             1D linecut data after integration.
+
         """
 
         # Extract necessary attributes from the object
@@ -478,8 +517,7 @@ class Scissors:
         center = center if center is not None else self.center
         self.set_center(center)
         window = window if window is not None else self.window
-        self.set_window(window)
-        axis = axis if axis is not None else self.axis
+        self.set_window(window, axis, verbose)
 
         # Convert the center to a tuple of floats
         center = tuple(float(c) for c in center)
@@ -500,7 +538,7 @@ class Scissors:
 
         # Create an NXdata object for the linecut data
         self.linecut = NXdata(NXfield(integrated_data, name=self.integration_volume.signal),
-                              self.integration_volume[self.integration_volume.axes[axis]])
+                              self.integration_volume[self.integration_volume.axes[self.axis]])
         self.linecut.nxname = self.integration_volume.nxname
 
         return self.linecut
@@ -526,7 +564,6 @@ class Scissors:
         data = self.data if data is None else data
         center = self.center
         window = self.window
-        integrated_axes = self.integrated_axes
 
         # Create a figure and subplots
         fig, axes = plt.subplots(1, 3, figsize=(15, 4))
@@ -545,7 +582,8 @@ class Scissors:
             (center[0] - window[0],
              center[1] - window[1]),
             2 * window[0], 2 * window[1],
-            linewidth=1, edgecolor=highlight_color, facecolor='none', transform=p1.get_transform(), label=label,
+            linewidth=1, edgecolor=highlight_color,
+            facecolor='none', transform=p1.get_transform(), label=label,
         )
         ax.add_patch(rect_diffuse)
 
@@ -563,7 +601,8 @@ class Scissors:
             (center[0] - window[0],
              center[2] - window[2]),
             2 * window[0], 2 * window[2],
-            linewidth=1, edgecolor=highlight_color, facecolor='none', transform=p2.get_transform(), label=label,
+            linewidth=1, edgecolor=highlight_color,
+            facecolor='none', transform=p2.get_transform(), label=label,
         )
         ax.add_patch(rect_diffuse)
 
@@ -581,7 +620,8 @@ class Scissors:
             (center[1] - window[1],
              center[2] - window[2]),
             2 * window[1], 2 * window[2],
-            linewidth=1, edgecolor=highlight_color, facecolor='none', transform=p3.get_transform(), label=label,
+            linewidth=1, edgecolor=highlight_color,
+            facecolor='none', transform=p3.get_transform(), label=label,
         )
         ax.add_patch(rect_diffuse)
 
@@ -605,10 +645,7 @@ class Scissors:
             Additional keyword arguments to customize the plot.
         """
         data = self.integration_volume
-        axis = self.axis
         center = self.center
-        window = self.window
-        integrated_axes = self.integrated_axes
 
         fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
@@ -651,6 +688,23 @@ class Scissors:
 
 
 def reciprocal_lattice_params(lattice_params):
+    """
+    Calculate the reciprocal lattice parameters from the given direct lattice parameters.
+
+    Parameters
+    ----------
+    lattice_params : tuple
+        A tuple containing the direct lattice parameters (a, b, c, alpha, beta, gamma), where
+        a, b, and c are the magnitudes of the lattice vectors, and alpha, beta, and gamma are the
+        angles between them in degrees.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the reciprocal lattice parameters (a*, b*, c*, alpha*, beta*, gamma*),
+        where a*, b*, and c* are the magnitudes of the reciprocal lattice vectors, and alpha*,
+        beta*, and gamma* are the angles between them in degrees.
+    """
     a_mag, b_mag, c_mag, alpha, beta, gamma = lattice_params
     # Convert angles to radians
     alpha = np.deg2rad(alpha)
@@ -659,17 +713,20 @@ def reciprocal_lattice_params(lattice_params):
 
     # Calculate unit cell volume
     V = a_mag * b_mag * c_mag * np.sqrt(
-        1 - np.cos(alpha) ** 2 - np.cos(beta) ** 2 - np.cos(gamma) ** 2 + 2 * np.cos(alpha) * np.cos(beta) * np.cos(
-            gamma)
+        1 - np.cos(alpha) ** 2 - np.cos(beta) ** 2 - np.cos(gamma) ** 2
+        + 2 * np.cos(alpha) * np.cos(beta) * np.cos(gamma)
     )
 
     # Calculate reciprocal lattice parameters
     a_star = (b_mag * c_mag * np.sin(alpha)) / V
     b_star = (a_mag * c_mag * np.sin(beta)) / V
     c_star = (a_mag * b_mag * np.sin(gamma)) / V
-    alpha_star = np.rad2deg(np.arccos((np.cos(beta) * np.cos(gamma) - np.cos(alpha)) / (np.sin(beta) * np.sin(gamma))))
-    beta_star = np.rad2deg(np.arccos((np.cos(alpha) * np.cos(gamma) - np.cos(beta)) / (np.sin(alpha) * np.sin(gamma))))
-    gamma_star = np.rad2deg(np.arccos((np.cos(alpha) * np.cos(beta) - np.cos(gamma)) / (np.sin(alpha) * np.sin(beta))))
+    alpha_star = np.rad2deg(np.arccos((np.cos(beta) * np.cos(gamma) - np.cos(alpha))
+                                      / (np.sin(beta) * np.sin(gamma))))
+    beta_star = np.rad2deg(np.arccos((np.cos(alpha) * np.cos(gamma) - np.cos(beta))
+                                     / (np.sin(alpha) * np.sin(gamma))))
+    gamma_star = np.rad2deg(np.arccos((np.cos(alpha) * np.cos(beta) - np.cos(gamma))
+                                      / (np.sin(alpha) * np.sin(beta))))
 
     return a_star, b_star, c_star, alpha_star, beta_star, gamma_star
 
@@ -689,9 +746,10 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
     rotation_axis : int
         Axis of rotation (0, 1, or 2).
     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. 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
@@ -714,7 +772,8 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
 
     for i in range(len(data[data.axes[rotation_axis]])):
         if printout:
-            print(f'\rRotating {data.axes[rotation_axis]}={data[data.axes[rotation_axis]][i]}...                      ',
+            print(f'\rRotating {data.axes[rotation_axis]}'
+                  f'={data[data.axes[rotation_axis]][i]}...                      ',
                   end='', flush=True)
         # Identify current slice
         if rotation_axis == 0:
@@ -727,12 +786,14 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
             sliced_data = None
 
         p = Padder(sliced_data)
-        padding = tuple([len(sliced_data[axis]) for axis in sliced_data.axes])
+        padding = tuple(len(sliced_data[axis]) for axis in sliced_data.axes)
         counts = p.pad(padding).counts
 
         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],
+                                                 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)
@@ -751,15 +812,18 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
 
         counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                    Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
+                                                    Affine2D().scale(
+                                                        scale2, 1
+                                                    ).inverted().get_matrix()[:2, :2],
                                                     offset=[-(1 - scale2) * counts.shape[
                                                         0] / 2 / scale2, 0],
                                                     order=0,
                                                     )
 
         counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
-                                                    Affine2D().scale(scale1,
-                                                                     1).inverted().get_matrix()[:2, :2],
+                                                    Affine2D().scale(
+                                                        scale1, 1
+                                                    ).inverted().get_matrix()[:2, :2],
                                                     offset=[-(1 - scale1) * counts.shape[
                                                         0] / 2 / scale1, 0],
                                                     order=0,
@@ -768,7 +832,8 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         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)),
+                                                       (-counts.shape[0] / 2
+                                                        * np.sin(skew_angle_adj * np.pi / 180)),
                                                        0],
                                                    order=0,
                                                    )
@@ -786,9 +851,10 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
     return NXdata(NXfield(output_array, name='counts'),
                   (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
 
+
 def rotate_data2D(data, lattice_angle, rotation_angle):
     """
-    Rotates 3D data around a specified axis.
+    Rotates 2D data.
 
     Parameters
     ----------
@@ -797,7 +863,7 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     lattice_angle : float
         Angle between the two in-plane lattice axes in degrees.
     rotation_angle : float
-        Angle of rotation in degrees..
+        Angle of rotation in degrees.
 
 
     Returns
@@ -817,12 +883,13 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180)).inverted()
 
     p = Padder(data)
-    padding = tuple([len(data[axis]) for axis in data.axes])
+    padding = tuple(len(data[axis]) for axis in data.axes)
     counts = p.pad(padding).counts
 
     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],
+                                             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)
@@ -841,15 +908,18 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     counts_rotated = ndimage.rotate(counts_scaled2, rotation_angle, reshape=False, order=0)
 
     counts_unscaled2 = ndimage.affine_transform(counts_rotated,
-                                                Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
+                                                Affine2D().scale(
+                                                    scale2, 1
+                                                ).inverted().get_matrix()[:2, :2],
                                                 offset=[-(1 - scale2) * counts.shape[
                                                     0] / 2 / scale2, 0],
                                                 order=0,
                                                 )
 
     counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
-                                                Affine2D().scale(scale1,
-                                                                 1).inverted().get_matrix()[:2, :2],
+                                                Affine2D().scale(
+                                                    scale1, 1
+                                                ).inverted().get_matrix()[:2, :2],
                                                 offset=[-(1 - scale1) * counts.shape[
                                                     0] / 2 / scale1, 0],
                                                 order=0,
@@ -858,7 +928,8 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     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)),
+                                                   (-counts.shape[0] / 2
+                                                    * np.sin(skew_angle_adj * np.pi / 180)),
                                                    0],
                                                order=0,
                                                )
@@ -870,20 +941,44 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
                   (data[data.axes[0]], data[data.axes[1]]))
 
 
-class Padder():
+class Padder:
     """
-    A class to pad and unpad datasets with a symmetric region of zeros.
+    A class to symmetrically pad and unpad datasets with a region of zeros.
+
+    Attributes
+    ----------
+    data : NXdata or None
+        The input data to be padded.
+    padded : NXdata or None
+        The padded data with symmetric zero padding.
+    padding : tuple or None
+        The number of zero-value pixels added along each edge of the array.
+    steps : tuple or None
+        The step sizes along each axis of the dataset.
+    maxes : tuple or None
+        The maximum values along each axis of the dataset.
+
+    Methods
+    -------
+    set_data(data)
+        Set the input data for padding.
+    pad(padding)
+        Symmetrically pads the data with zero values.
+    save(fout_name=None)
+        Saves the padded dataset to a .nxs file.
+    unpad(data)
+        Removes the padded region from the data.
     """
 
     def __init__(self, data=None):
         """
-        Initialize the Symmetrizer3D object.
+        Initialize the Padder object.
 
         Parameters
         ----------
         data : NXdata, optional
-            The input data to be symmetrized. If provided, the `set_data` method is called to set the data.
-
+            The input data to be padded. If provided, the `set_data` method
+            is called to set the data.
         """
         self.padded = None
         self.padding = None
@@ -892,20 +987,21 @@ class Padder():
 
     def set_data(self, data):
         """
-        Set the input data for symmetrization.
+        Set the input data for padding.
 
         Parameters
         ----------
         data : NXdata
-            The input data to be symmetrized.
-
+            The input data to be padded.
         """
         self.data = data
 
-        self.steps = tuple([(data[axis].nxdata[1] - data[axis].nxdata[0]) for axis in data.axes])
+        self.steps = tuple((data[axis].nxdata[1] - data[axis].nxdata[0])
+                            for axis in data.axes)
 
-        # Absolute value of the maximum value; assumes the domain of the input is symmetric (eg, -H_min = H_max)
-        self.maxes = tuple([data[axis].nxdata.max() for axis in data.axes])
+        # Absolute value of the maximum value; assumes the domain of the input
+        # is symmetric (eg, -H_min = H_max)
+        self.maxes = tuple(data[axis].nxdata.max() for axis in data.axes)
 
     def pad(self, padding):
         """
@@ -915,11 +1011,17 @@ class Padder():
         ----------
         padding : tuple
             The number of zero-value pixels to add along each edge of the array.
+
+        Returns
+        -------
+        NXdata
+            The padded data with symmetric zero padding.
         """
         data = self.data
         self.padding = padding
 
-        padded_shape = tuple([data[data.signal].nxdata.shape[i] + self.padding[i] * 2 for i in range(data.ndim)])
+        padded_shape = tuple(data[data.signal].nxdata.shape[i]
+                             + self.padding[i] * 2 for i in range(data.ndim))
 
         # Create padded dataset
         padded = np.zeros(padded_shape)
@@ -930,12 +1032,13 @@ class Padder():
         slice_obj = tuple(slice_obj)
         padded[slice_obj] = data[data.signal].nxdata
 
-        padmaxes = tuple([self.maxes[i] + self.padding[i] * self.steps[i] for i in range(data.ndim)])
+        padmaxes = tuple(self.maxes[i] + self.padding[i] * self.steps[i]
+                         for i in range(data.ndim))
 
         padded = NXdata(NXfield(padded, name=data.signal),
-                        tuple([NXfield(np.linspace(-padmaxes[i], padmaxes[i], padded_shape[i]),
-                                       name=data.axes[i])
-                               for i in range(data.ndim)]))
+                        tuple(NXfield(np.linspace(-padmaxes[i], padmaxes[i], padded_shape[i]),
+                                      name=data.axes[i])
+                              for i in range(data.ndim)))
 
         self.padded = padded
         return padded
@@ -974,16 +1077,38 @@ class Padder():
         -------
         ndarray or NXdata
             The unpadded data, with the symmetric padding region removed.
-
-        Notes
-        -----
-        This method removes the symmetric padding region that was added using the `pad` method. It returns the data
-        without the padded region.
-
-
         """
         slice_obj = [slice(None)] * data.ndim
         for i in range(data.ndim):
             slice_obj[i] = slice(self.padding[i], -self.padding[i], None)
         slice_obj = tuple(slice_obj)
         return data[slice_obj]
+
+
+def load_discus_nxs(path):
+    """
+    Load .nxs format data from the DISCUS program (by T. Proffen and R. Neder)
+    and convert it to the CHESS format.
+
+    Parameters
+    ----------
+    path : str
+        The file path to the .nxs file generated by DISCUS.
+
+    Returns
+    -------
+    NXdata
+        The data converted to the CHESS format, with axes labeled 'H', 'K', and 'L',
+        and the signal labeled 'counts'.
+
+    """
+    filename = path
+    root = nxload(filename)
+    hlim, klim, llim = root.lower_limits
+    hstep, kstep, lstep = root.step_sizes
+    h = NXfield(np.linspace(hlim, -hlim, int(np.abs(hlim * 2) / hstep) + 1), name='H')
+    k = NXfield(np.linspace(klim, -klim, int(np.abs(klim * 2) / kstep) + 1), name='K')
+    l = NXfield(np.linspace(llim, -llim, int(np.abs(llim * 2) / lstep) + 1), name='L')
+    data = NXdata(NXfield(root.data[:, :, :], name='counts'), (h, k, l))
+
+    return data