nxs-analysis-tools 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

_meta/__init__.py

@@ -1,4 +1,4 @@
-'''MagentroPy package metadata.'''
+'''nxs-analysis-tools package metadata.'''
 
 # keep consistent with pyproject.toml
 __project__ = 'nxs-analysis-tools'
@@ -6,5 +6,5 @@ __author__ = 'Steven J. Gomez Alvarado'
 __email__ = 'stevenjgomez@ucsb.edu'
 __copyright__ = f"2023, {__author__}"
 __license__ = 'MIT'
-__version__= '0.0.18'
+__version__= '0.0.20'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

nxs_analysis_tools/chess.py

@@ -4,6 +4,7 @@ This module provides classes and functions for analyzing scattering datasets col
 plotting linecuts.
 '''
 import os
+
 import matplotlib.pyplot as plt
 import matplotlib as mpl
 
@@ -14,6 +15,7 @@ class TempDependence():
     '''
     Class for analyzing scattering datasets collected at CHESS (ID4B) with temperature dependence.
     '''
+
     def __init__(self):
         '''
         Initialize TempDependence class.
@@ -21,8 +23,8 @@ class TempDependence():
         self.datasets={}
         self.folder=None
         self.temperatures=None
-        self.scissors=None
-        self.linecuts=None
+        self.scissors= {}
+        self.linecuts={}
 
     def get_folder(self):
         '''
@@ -81,40 +83,42 @@ class TempDependence():
                     print('-----------------------------------------------')
                     print('Loading ' + temperature + ' K indexed .nxs files...')
                     print('Found ' + filepath)
-                    self.datasets[temperature] = load_data(filepath)
 
-        self.scissors = [Scissors() for _ in range(len(self.datasets))]
+                    # Load dataset at each temperature
+                    self.datasets[temperature] = load_data(filepath)
 
-        for i,dataset in enumerate(self.datasets.values()):
-            self.scissors[i].set_data(dataset)
+                    # Initialize scissors object at each temperature
+                    self.scissors[temperature] = Scissors()
+                    self.scissors[temperature].set_data(self.datasets[temperature])
 
     def set_window(self, window):
-        '''
+        """
         Set the extents of the integration window.
 
         Parameters
         ----------
         window : tuple
             Extents of the window for integration along each axis.
-        '''
-        for i,scissors in enumerate(self.scissors):
+        """
+        for T in self.temperatures:
             print("----------------------------------")
-            print("T = " + self.temperatures[i] + " K")
-            scissors.set_window(window)
+            print("T = " + T + " K")
+            self.scissors[T].set_window(window)
 
     def set_center(self, center):
-        '''
+        """
         Set the central coordinate for the linecut.
 
         Parameters
         ----------
         center : tuple
             Central coordinate around which to perform the linecut.
-        '''
-        [scissors.set_center(center) for scissors in self.scissors]
+        """
+        for T in self.temperatures:
+            self.scissors[T].set_center(center)
 
     def cut_data(self, center=None, window=None, axis=None):
-        '''
+        """
         Perform data cutting for each temperature dataset.
 
         Parameters
@@ -131,21 +135,20 @@ class TempDependence():
         -------
         list
             A list of linecuts obtained from the cutting operation.
-        '''
+        """
 
-        center = center if center is not None else self.scissors[0].center
-        window = window if window is not None else self.scissors[0].window
+        center = center if center is not None else self.scissors[self.temperatures[0]].center
+        window = window if window is not None else self.scissors[self.temperatures[0]].window
 
-        for i,T in enumerate(self.temperatures):
+        for T in self.temperatures:
             print("-------------------------------")
             print("Cutting T = " + T + " K data...")
-            self.scissors[i].cut_data(center, window, axis)
-
-        self.linecuts = [scissors.linecut for scissors in self.scissors]
+            self.scissors[T].cut_data(center, window, axis)
+            self.linecuts[T] = self.scissors[T].linecut
         return self.linecuts
 
     def plot_linecuts(self, vertical_offset=0, **kwargs):
-        '''
+        """
         Plot the linecuts obtained from data cutting.
 
         Parameters
@@ -154,23 +157,24 @@ class TempDependence():
             The vertical offset between linecuts on the plot. The default is 0.
         **kwargs
             Additional keyword arguments to be passed to the plot function.
-        '''
+        """
         fig, ax = plt.subplots()
 
         # Get the Viridis colormap
         cmap = mpl.colormaps.get_cmap('viridis')
 
-        for i, linecut in enumerate(self.linecuts):
+        for i, linecut in enumerate(self.linecuts.values()):
             x_data = linecut[linecut.axes[0]].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)
 
-        xlabel_components = [self.linecuts[0].axes[0] if i == self.scissors[0].axis \
-        	else str(c) for i,c in enumerate(self.scissors[0].center)]
+        xlabel_components = [self.linecuts[self.temperatures[0]].axes[0]
+                             if i == self.scissors[self.temperatures[0]].axis \
+                                 else str(c) for i,c in enumerate(self.scissors[self.temperatures[0]].center)]
         xlabel = ' '.join(xlabel_components)
         ax.set(xlabel=xlabel,
-                ylabel=self.linecuts[0].signal)
+                ylabel=self.linecuts[self.temperatures[0]].signal)
 
         # Get the current legend handles and labels
         handles, labels = plt.gca().get_legend_handles_labels()
@@ -184,9 +188,9 @@ class TempDependence():
 
         return fig,ax
 
-    def show_integration_window(self, temperature=None):
-        '''
-        Displays the integration window plot for a specific temperature or for all temperatures if
+    def highlight_integration_window(self, temperature=None, **kwargs):
+        """
+        Displays the integration window plot for a specific temperature, or for the first temperature if
         none is provided.
 
         Parameters
@@ -194,10 +198,39 @@ class TempDependence():
         temperature : str, optional
             The temperature at which to display the integration window plot. If provided, the plot
             will be generated using the dataset corresponding to the specified temperature. If not
-            provided, the integration window plots will be generated for all available
-            temperatures.
-        '''
+            provided, the integration window plots will be generated for the first temperature.
+        **kwargs : keyword arguments, optional
+            Additional keyword arguments to customize the plot.
+        """
+
         if temperature is not None:
-            self.scissors[0].show_integration_window(data=self.datasets[temperature])
+            p = self.scissors[self.temperatures[0]].highlight_integration_window(data=self.datasets[temperature],
+                                                                                 **kwargs)
         else:
-            self.scissors[0].show_integration_window(data=self.datasets[self.temperatures[0]])
+            p = self.scissors[self.temperatures[0]].highlight_integration_window(
+                data=self.datasets[self.temperatures[0]], **kwargs
+            )
+
+        return p
+
+    def plot_integration_window(self, temperature=None, **kwargs):
+        """
+        Plots the three principal cross-sections of the integration volume on a single figure for a specific
+        temperature, or for the first temperature if none is provided.
+
+        Parameters
+        ----------
+        temperature : str, optional
+            The temperature at which to plot the integration volume. If provided, the plot
+            will be generated using the dataset corresponding to the specified temperature. If not
+            provided, the integration window plots will be generated for the first temperature.
+        **kwargs : keyword arguments, optional
+            Additional keyword arguments to customize the plot.
+        """
+
+        if temperature is not None:
+            p = self.scissors[self.temperatures[0]].plot_integration_window(**kwargs)
+        else:
+            p = self.scissors[self.temperatures[0]].plot_integration_window(**kwargs)
+
+        return p

nxs_analysis_tools/datareduction.py

@@ -12,10 +12,11 @@ from matplotlib import patches
 from IPython.display import display, Markdown
 from nexusformat.nexus import NXfield, NXdata, nxload
 
-__all__=['load_data','plot_slice','Scissors']
+__all__ = ['load_data', 'plot_slice', 'Scissors']
+
 
 def load_data(path):
-    '''
+    """
     Load data from a specified path.
 
     Parameters
@@ -28,7 +29,7 @@ def load_data(path):
     data : nxdata object
         The loaded data stored in a nxdata object.
 
-    '''
+    """
     g = nxload(path)
     try:
         print(g.entry.data.tree)
@@ -39,10 +40,10 @@ def load_data(path):
 
 
 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):
-
-    '''
+               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):
+    """
     Parameters
     ----------
     data : :class:`nexusformat.nexus.NXdata` object
@@ -107,10 +108,10 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
     -------
     p : :class:`matplotlib.collections.QuadMesh`
 
-        A :class:`matplotlib.collections.QuadMesh` object, to mimick behavior of 
+        A :class:`matplotlib.collections.QuadMesh` object, to mimick behavior of
         :class:`matplotlib.pyplot.pcolormesh`.
 
-    '''
+    """
 
     if X is None:
         X = data[data.axes[0]]
@@ -132,18 +133,18 @@ 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()
+        ax = ax
+        fig = ax.get_figure()
     # Otherwise set up some default axes
     else:
         fig = plt.figure()
-        ax = fig.add_axes([0,0,1,1])
+        ax = fig.add_axes([0, 0, 1, 1])
 
     # If limits not provided, use extrema
     if vmin is None:
-        vmin=data_arr.min()
+        vmin = data_arr.min()
     if vmax is None:
-        vmax=data_arr.max()
+        vmax = data_arr.max()
 
     # Set norm (linear scale, logscale, or symlogscale)
     norm = colors.Normalize(vmin=vmin, vmax=vmax)  # Default: linear scale
@@ -153,42 +154,41 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
     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)
+    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 = 90-skew_angle
+    skew_angle = 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*np.pi/180))
+    t += Affine2D().scale(1, np.cos(skew_angle * np.pi / 180))
     # Shear along x-axis
-    t += Affine2D().skew_deg(skew_angle,0)
+    t += Affine2D().skew_deg(skew_angle, 0)
     # Return to original y-axis scaling
-    t += Affine2D().scale(1,np.cos(skew_angle*np.pi/180)).inverted()
+    t += Affine2D().scale(1, np.cos(skew_angle * np.pi / 180)).inverted()
     ## Correct for x-displacement after shearing
     # If ylims provided, use those
     if ylim is not None:
         # Set ylims
         ax.set(ylim=ylim)
-        ymin,ymax = ylim
+        ymin, ymax = ylim
     # Else, use current ylims
     else:
-        ymin,ymax = ax.get_ylim()
+        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*np.pi/180),0) + ax.transData)
+    p.set_transform(t + Affine2D().translate(-ymin * np.sin(skew_angle * np.pi / 180), 0) + ax.transData)
 
     # Set x limits
     if xlim is not None:
-        xmin,xmax = xlim
+        xmin, xmax = xlim
     else:
-        xmin,xmax = ax.get_xlim()
-    ax.set(xlim=(xmin,xmax+(ymax-ymin)/np.tan((90-skew_angle)*np.pi/180)))
+        xmin, xmax = ax.get_xlim()
+    ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - skew_angle) * np.pi / 180)))
 
     # Correct aspect ratio for the x/y axes after transformation
-    ax.set(aspect=np.cos(skew_angle*np.pi/180))
+    ax.set(aspect=np.cos(skew_angle * np.pi / 180))
 
     # Add tick marks all around
     ax.tick_params(direction='in', top=True, right=True, which='both')
@@ -209,41 +209,41 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
         ax.yaxis.set_major_locator(MultipleLocator(yticks))
         ax.yaxis.set_minor_locator(MultipleLocator(1))
 
-    ## Apply transform to tick marks
-    for i in range(0,len(ax.xaxis.get_ticklines())):
+    # Apply transform to tick marks
+    for i in range(0, len(ax.xaxis.get_ticklines())):
         # Tick marker
         m = MarkerStyle(3)
-        line =  ax.xaxis.get_majorticklines()[i]
-        if i%2:
+        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,0))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_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) +
             #     line.get_transform())
             # This second method skews the tick marks in place and
             # can sometimes lead to them being misaligned.
-            line.set_transform(line.get_transform()) # This does nothing
+            line.set_transform(line.get_transform())  # This does nothing
         else:
             # Bottom ticks
-            m._transform.set(Affine2D().skew_deg(skew_angle,0))
+            m._transform.set(Affine2D().skew_deg(skew_angle, 0))
 
         line.set_marker(m)
 
-    for i in range(0,len(ax.xaxis.get_minorticklines())):
+    for i in range(0, len(ax.xaxis.get_minorticklines())):
         m = MarkerStyle(2)
-        line =  ax.xaxis.get_minorticklines()[i]
-        if i%2:
-            m._transform.set(Affine2D().translate(0,-1) + Affine2D().skew_deg(skew_angle,0))
+        line = ax.xaxis.get_minorticklines()[i]
+        if i % 2:
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle, 0))
         else:
-            m._transform.set(Affine2D().skew_deg(skew_angle,0))
+            m._transform.set(Affine2D().skew_deg(skew_angle, 0))
 
         line.set_marker(m)
 
     if cbar:
         colorbar = fig.colorbar(p)
-    if cbartitle is None:
-        colorbar.set_label(data.signal)
+        if cbartitle is None:
+            colorbar.set_label(data.signal)
 
     ax.set(
         xlabel=X.nxname,
@@ -256,8 +256,9 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
     # Return the quadmesh object
     return p
 
-class Scissors():
-    '''
+
+class Scissors:
+    """
     Scissors class provides functionality for reducing data to a 1D linecut using an integration
     window.
 
@@ -298,10 +299,10 @@ class Scissors():
         Plot the integration window highlighted on a 2D heatmap of the full dataset.
     plot_window()
         Plot a 2D heatmap of the integration window data.
-    '''
+    """
 
     def __init__(self, data=None, center=None, window=None, axis=None):
-        '''
+        """
         Initializes a Scissors object.
 
         Parameters
@@ -314,7 +315,7 @@ class Scissors():
             Extents of the window for integration along each axis. Default is None.
         axis : int or None, optional
             Axis along which to perform the integration. Default is None.
-        '''
+        """
 
         self.data = data
         self.center = center
@@ -327,74 +328,74 @@ class Scissors():
         self.integration_window = None
 
     def set_data(self, data):
-        '''
+        """
         Set the input NXdata.
 
         Parameters
         ----------
         data : :class:`nexusformat.nexus.NXdata`
             Input data array.
-        '''
+        """
         self.data = data
 
     def get_data(self):
-        '''
+        """
         Get the input data array.
 
         Returns
         -------
         ndarray or None
             Input data array.
-        '''
+        """
         return self.data
 
     def set_center(self, center):
-        '''
+        """
         Set the central coordinate for the linecut.
 
         Parameters
         ----------
         center : tuple
             Central coordinate around which to perform the linecut.
-        '''
+        """
         self.center = center
 
     def set_window(self, window):
-        '''
+        """
         Set the extents of the integration window.
 
         Parameters
         ----------
         window : tuple
             Extents of the window for integration along each axis.
-        '''
+        """
         self.window = window
 
         # Determine the axis for integration
         self.axis = window.index(max(window))
-        print("Linecut axis: "+str(self.data.axes[self.axis]))
+        print("Linecut axis: " + str(self.data.axes[self.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]))
+        print("Integrated axes: " + str([self.data.axes[axis] for axis in self.integrated_axes]))
 
     def get_window(self):
-        '''
+        """
         Get the extents of the integration window.
 
         Returns
         -------
         tuple or None
             Extents of the integration window.
-        '''
+        """
         return self.window
 
     def cut_data(self, center=None, window=None, axis=None):
-        '''
+        """
         Reduces data to a 1D linecut with integration extents specified by the window about a central
         coordinate.
 
-        Parameters:
+        Parameters
         -----------
         center : float or None, optional
             Central coordinate for the linecut. If not specified, the value from the object's
@@ -406,11 +407,11 @@ class Scissors():
             The axis along which to perform the linecut. If not specified, the value from the
             object's attribute will be used.
 
-        Returns:
+        Returns
         --------
         integrated_data : :class:`nexusformat.nexus.NXdata`
             1D linecut data after integration.
-        '''
+        """
 
         # Extract necessary attributes from the object
         data = self.data
@@ -435,104 +436,155 @@ class Scissors():
 
         # Perform integration along the integrated axes
         integrated_data = np.sum(self.integration_volume[self.integration_volume.signal].nxdata,
-            axis=self.integrated_axes)
+                                 axis=self.integrated_axes)
 
         # 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[axis]])
         self.linecut.nxname = self.integration_volume.nxname
 
         return self.linecut
 
-    def show_integration_window(self, data=None, label=None, **kwargs):
-        '''
-        Plots integration window highlighted on 2D heatmap full dataset.
+    def highlight_integration_window(self, data=None, label=None, highlight_color='red', **kwargs):
+        """
+        Plots integration window highlighted on the three principal cross sections of the first
+        temperature dataset.
 
         Parameters
         ----------
         data : array-like, optional
-            The 2D heatmap dataset to plot. If not provided, the dataset stored in `self.data` will be used.
+            The 2D heatmap dataset to plot. If not provided, the dataset stored in `self.data` will
+            be used.
         label : str, optional
             The label for the integration window plot.
+        highlight_color : str, optional
+            The edge color used to highlight the integration window. Default is 'red'.
         **kwargs : keyword arguments, optional
             Additional keyword arguments to customize the plot.
 
-        '''
+        """
         data = self.data if data is None else data
-        axis = self.axis
         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))
+
         # Plot cross section 1
-        slice_obj = [slice(None)]*data.ndim
-        slice_obj[axis] = center[axis]
+        slice_obj = [slice(None)] * data.ndim
+        slice_obj[2] = center[2]
 
         p1 = plot_slice(data[slice_obj],
-                       X=data[data.axes[integrated_axes[0]]],
-                       Y=data[data.axes[integrated_axes[1]]],
-                       **kwargs)
-        ax = plt.gca()
+                        X=data[data.axes[0]],
+                        Y=data[data.axes[1]],
+                        ax=axes[0],
+                        **kwargs)
+        ax = axes[0]
         rect_diffuse = patches.Rectangle(
-            (center[integrated_axes[0]]-window[integrated_axes[0]],
-            center[integrated_axes[1]]-window[integrated_axes[1]]),
-            2*window[integrated_axes[0]], 2*window[integrated_axes[1]],
-            linewidth=1, edgecolor='r', facecolor='none', transform=p1.get_transform(), label=label,
-            )
+            (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,
+        )
         ax.add_patch(rect_diffuse)
-        plt.show()
 
         # Plot cross section 2
-        slice_obj = [slice(None)]*data.ndim
-        slice_obj[integrated_axes[1]] = center[integrated_axes[1]]
+        slice_obj = [slice(None)] * data.ndim
+        slice_obj[1] = center[1]
 
         p2 = plot_slice(data[slice_obj],
-                       X=data[data.axes[integrated_axes[0]]],
-                       Y=data[data.axes[axis]],
-                       **kwargs)
-        ax = plt.gca()
+                        X=data[data.axes[0]],
+                        Y=data[data.axes[2]],
+                        ax=axes[1],
+                        **kwargs)
+        ax = axes[1]
         rect_diffuse = patches.Rectangle(
-            (center[integrated_axes[0]]-window[integrated_axes[0]],
-            center[axis]-window[axis]),
-            2*window[integrated_axes[0]], 2*window[axis],
-            linewidth=1, edgecolor='r', facecolor='none', transform=p2.get_transform(), label=label,
-            )
+            (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,
+        )
         ax.add_patch(rect_diffuse)
-        plt.show()
 
         # Plot cross section 3
-        slice_obj = [slice(None)]*data.ndim
-        slice_obj[integrated_axes[0]] = center[integrated_axes[0]]
+        slice_obj = [slice(None)] * data.ndim
+        slice_obj[0] = center[0]
 
         p3 = plot_slice(data[slice_obj],
-                       X=data[data.axes[integrated_axes[1]]],
-                       Y=data[data.axes[axis]],
-                       **kwargs)
-        ax = plt.gca()
+                        X=data[data.axes[1]],
+                        Y=data[data.axes[2]],
+                        ax=axes[2],
+                        **kwargs)
+        ax = axes[2]
         rect_diffuse = patches.Rectangle(
-            (center[integrated_axes[1]]-window[integrated_axes[1]],
-            center[axis]-window[axis]),
-           2*window[integrated_axes[1]], 2*window[axis],
-            linewidth=1, edgecolor='r', facecolor='none', transform=p3.get_transform(), label=label,
-            )
+            (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,
+        )
         ax.add_patch(rect_diffuse)
+
+        # Adjust subplot padding
+        fig.subplots_adjust(wspace=0.5)
+
+        if label is not None:
+            [ax.legend() for ax in axes]
+
         plt.show()
 
-        return (p1,p2,p3)
+        return p1, p2, p3
+
+    def plot_integration_window(self, **kwargs):
+        """
+        Plots the three principal cross-sections of the integration volume on a single figure.
+
+        Parameters
+        ----------
+        **kwargs : keyword arguments, optional
+            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))
 
-    # def plot_window(self):
-    #     '''
-    #     Plots 2D heatmap of integration window data on its own.
-    #     '''
-    #     data = self.integration_volume
+        # Plot cross section 1
+        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]],
+                        ax=axes[0],
+                        **kwargs)
+        axes[0].set_aspect(len(data[data.axes[0]].nxdata) / len(data[data.axes[1]].nxdata))
 
-    #     # TODO: Adjust code to plot 3 different cross sections, create slice_obj
-    #     p = plot_slice(
-    #         data[slice_obj],
-    #         data[data.axes[self.integrated_axes[0]]],
-    #         data[data.axes[self.integrated_axes[1]]],
-    #         vmin=1, logscale=True,
-    #         )
-    #     plt.show()
+        # 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]],
+                        ax=axes[1],
+                        **kwargs)
+        axes[1].set_aspect(len(data[data.axes[0]].nxdata) / len(data[data.axes[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]],
+                        ax=axes[2],
+                        **kwargs)
+        axes[2].set_aspect(len(data[data.axes[1]].nxdata) / len(data[data.axes[2]].nxdata))
+
+        # Adjust subplot padding
+        fig.subplots_adjust(wspace=0.3)
+
+        plt.show()
 
-    #     return
+        return p1, p2, p3

nxs_analysis_tools/pairdistribution.py

@@ -1,80 +1,438 @@
+"""
+Tools for generating single crystal pair distribution functions.
+"""
+import time
+import os
 from scipy import ndimage
+import matplotlib.pyplot as plt
 from matplotlib.transforms import Affine2D
+from nexusformat.nexus import nxsave, NXroot, NXentry, NXdata, NXfield
 import numpy as np
+from nxs_analysis_tools import plot_slice
 
-def symmetrize_2d(q1, q2, counts, theta_min, theta_max, skew_angle=90, mirror=True):
+
+class Padder():
     """
-    Symmetrizes a 2D dataset within a specified angular range.
-
-    Parameters:
-        q1 (ndarray): Array of shape (M,) representing the values of axis q1.
-        q2 (ndarray): Array of shape (N,) representing the values of axis q2.
-        counts (ndarray): 2D array of shape (M, N) representing the counts at each (q1,q2) coordinate.
-        theta_min (float): Minimum angle in degrees for the symmetrization range.
-        theta_max (float): Maximum angle in degrees for the symmetrization range.
-        skew_angle (float, optional): Skew angle in degrees. Default is 90.
-        mirror (bool, optional): Flag indicating whether to include a mirror operation during transformation. Default is True.
-
-    Returns:
-        ndarray: 2D array of shape (M, N) representing the symmetrized dataset.
+    A class to pad and unpad datasets with a symmetric region of zeros.
     """
 
+    def __init__(self, data=None):
+        """
+        Initialize the Symmetrizer3D object.
+
+        Parameters
+        ----------
+        data : NXdata, optional
+            The input data to be symmetrized. If provided, the `set_data` method is called to set the data.
+
+        """
+        if data is not None:
+            self.set_data(data)
+
+    def set_data(self, data):
+        """
+        Set the input data for symmetrization.
+
+        Parameters
+        ----------
+        data : NXdata
+            The input data to be symmetrized.
+
+        """
+        self.data = data
+
+        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])
+
+    def pad(self, padding):
+        """
+        Symmetrically pads the data with zero values.
+
+        Parameters
+        ----------
+        padding : tuple
+            The number of zero-value pixels to add along each edge of the array.
+        """
+        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)])
+
+        # Create padded dataset
+        padded = np.zeros(padded_shape)
+
+        slice_obj = [slice(None)] * data.ndim
+        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
+
+        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)]))
+
+        self.padded = padded
+        return padded
+
+    def save(self, fout_name=None):
+        """
+        Saves the padded dataset to a .nxs file.
+
+        Parameters
+        ----------
+        fout_name : str, optional
+            The output file name. Default is padded_(Hpadding)_(Kpadding)_(Lpadding).nxs
+        """
+        padH, padK, padL = self.padding
+
+        # Save padded dataset
+        print("Saving padded dataset...")
+        f = NXroot()
+        f['entry'] = NXentry()
+        f['entry']['data'] = self.padded
+        if fout_name is None:
+            fout_name = 'padded_' + str(padH) + '_' + str(padK) + '_' + str(padL) + '.nxs'
+        nxsave(fout_name, f)
+        print("Output file saved to: " + os.path.join(os.getcwd(), fout_name))
+
+    def unpad(self, data):
+        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]
+
+
+class Symmetrizer2D:
+    """
+    A class for symmetrizing 2D datasets.
+    """
+
+    def __init__(self, **kwargs):
+        if kwargs != {}:
+            self.set_parameters(**kwargs)
+
+    def set_parameters(self, theta_min, theta_max, skew_angle=90, mirror=True):
+        """
+        Sets the parameters for the symmetrization operation.
+
+        Parameters
+        ----------
+        theta_min : float
+            The minimum angle in degrees for symmetrization.
+        theta_max : float
+            The maximum angle in degrees for symmetrization.
+        skew_angle : float, optional
+            The angle in degrees to skew the data during symmetrization (default: 90).
+        mirror : bool, optional
+            If True, perform mirroring during symmetrization (default: True).
+        """
+        self.theta_min = theta_min
+        self.theta_max = theta_max
+        self.skew_angle = skew_angle
+        self.mirror = mirror
+
+        # Define Transformation
+        skew_angle_adj = 90 - skew_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
+
+        # Calculate number of rotations needed to reconstructed the dataset
+        if mirror:
+            rotations = abs(int(360 / (theta_max - theta_min) / 2))
+        else:
+            rotations = abs(int(360 / (theta_max - theta_min)))
+        self.rotations = rotations
+
+        self.symmetrization_mask = None
+
+        self.wedges = None
+
+        self.symmetrized = None
+
+    def symmetrize_2d(self, data):
+        """
+        Symmetrizes a 2D dataset based on the set parameters.
+
+        Parameters
+        ----------
+        data : NXdata
+            The input 2D dataset to be symmetrized.
+
+        Returns
+        -------
+        symmetrized : NXdata
+            The symmetrized 2D dataset.
+        """
+        theta_min = self.theta_min
+        theta_max = self.theta_max
+        mirror = self.mirror
+        t = self.transform
+        rotations = self.rotations
+
+        # Pad the dataset so that rotations don't get cutoff if they extend past the extent of the dataset
+        p = Padder(data)
+        padding = tuple([len(data[axis]) for axis in data.axes])
+        data_padded = p.pad(padding)
+
+        # Define axes that span the plane to be transformed
+        q1 = data_padded[data.axes[0]]
+        q2 = data_padded[data.axes[1]]
+
+        # Define signal to be symmetrized
+        counts = data_padded[data.signal].nxdata
+
+        # Calculate the angle for each data point
+        theta = np.arctan2(q1.reshape((-1, 1)), q2.reshape((1, -1)))
+        # Create a boolean array for the range of angles
+        symmetrization_mask = np.logical_and(theta >= theta_min * np.pi / 180, theta <= theta_max * np.pi / 180)
+        self.symmetrization_mask = NXdata(NXfield(p.unpad(symmetrization_mask), name='mask'),
+                                          (data[data.axes[0]], data[data.axes[1]]))
+
+        self.wedge = NXdata(NXfield(p.unpad(counts * symmetrization_mask), name=data.signal),
+                            (data[data.axes[0]], data[data.axes[1]]))
+
+        # 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,
+                                         ) * symmetrization_mask
+
+        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],
+                                         order=0,
+                                         )
+
+        # Reconstruct full dataset from wedge
+        reconstructed = np.zeros(counts.shape)
+        for n 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))
+
+        if mirror:
+            # The following are attempts to combine images with minimal overlapping pixels
+            reconstructed = np.where(reconstructed == 0, reconstructed + np.flip(reconstructed, axis=0), reconstructed)
+            # reconstructed += np.flip(reconstructed, axis=0)
+
+        # self.rotated_and_mirrored = NXdata(NXfield(reconstructed, name=data.signal),
+        #                                    (q1, q2))
+
+        reconstructed = ndimage.affine_transform(reconstructed,
+                                                 Affine2D().scale(scale2, 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],
+                                                 order=0,
+                                                 )
+
+        reconstructed_unpadded = p.unpad(reconstructed)
+
+        # Fix any overlapping pixels by truncating counts to max
+        reconstructed_unpadded[reconstructed_unpadded > data[data.signal].nxdata.max()] = data[data.signal].nxdata.max()
+
+        symmetrized = NXdata(NXfield(reconstructed_unpadded, name=data.signal),
+                             (data[data.axes[0]],
+                              data[data.axes[1]]))
+
+        return symmetrized
+
+    def test(self, data):
+        """
+        Performs a test visualization of the symmetrization process.
+
+        Parameters
+        ----------
+        data : ndarray
+            The input 2D dataset to be used for the test visualization.
+
+        Returns
+        -------
+        fig : Figure
+            The matplotlib Figure object that contains the test visualization plot.
+        axesarr : ndarray
+            The numpy array of Axes objects representing the subplots in the test visualization.
+
+        Notes
+        -----
+        This method uses the `symmetrize_2d` method to perform the symmetrization on the input data and visualize
+        the process.
+
+        The test visualization plot includes the following subplots:
+        - Subplot 1: The original dataset.
+        - Subplot 2: The symmetrization mask.
+        - Subplot 3: The wedge slice used for reconstruction of the full symmetrized dataset.
+        - Subplot 4: The symmetrized dataset.
+
+        Example usage:
+        ```
+        s = Scissors()
+        s.set_parameters(theta_min, theta_max, skew_angle, mirror)
+        s.test(data)
+        ```
+        """
+        s = self
+        symm_test = s.symmetrize_2d(data)
+        fig, axesarr = plt.subplots(2, 2, figsize=(10, 8))
+        axes = axesarr.reshape(-1)
+        plot_slice(data, skew_angle=s.skew_angle, ax=axes[0], title='data')
+        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask')
+        plot_slice(s.wedge, ax=axes[2], title='wedge')
+        plot_slice(symm_test, skew_angle=s.skew_angle, ax=axes[3], title='symmetrized')
+        plt.subplots_adjust(wspace=0.4)
+        plt.show()
+        return fig, axesarr
+
+
+class Symmetrizer3D():
+    """
+    A class to symmetrize 3D datasets.
+    """
+
+    def __init__(self, data):
+        """
+        Initialize the Symmetrizer3D object.
+
+        Parameters
+        ----------
+        data : NXdata
+            The input 3D dataset to be symmetrized.
+
+        """
+        self.data = data
+        self.q1 = data[data.axes[0]]
+        self.q2 = data[data.axes[1]]
+        self.q3 = data[data.axes[2]]
+        self.plane1symmetrizer = Symmetrizer2D()
+        self.plane2symmetrizer = Symmetrizer2D()
+        self.plane3symmetrizer = Symmetrizer2D()
+        self.plane1 = self.q1.nxname + self.q2.nxname
+        self.plane2 = self.q1.nxname + self.q3.nxname
+        self.plane3 = self.q2.nxname + self.q3.nxname
+
+        print("Plane 1: " + self.plane1)
+        print("Plane 2: " + self.plane2)
+        print("Plane 3: " + self.plane3)
+
+    def symmetrize(self):
+        """
+        Perform the symmetrization of the 3D dataset.
+
+        Returns
+        -------
+        symmetrized : NXdata
+            The symmetrized 3D dataset.
+
+        """
+        starttime = time.time()
+        data = self.data
+        q1, q2, q3 = self.q1, self.q2, self.q3
+        out_array = np.zeros(data[data.signal].shape)
+
+        print('Symmetrizing ' + self.plane1 + ' planes...')
+        for k in range(0, len(q3)):
+            print('Symmetrizing ' + q3.nxname + '=' + "{:.02f}".format(q3[k]) + "...", end='\r')
+            data_symmetrized = self.plane1symmetrizer.symmetrize_2d(data[:, :, k])
+            out_array[:, :, k] = data_symmetrized[data.signal].nxdata
+        print('\nSymmetrized ' + self.plane1 + ' planes.')
+
+        print('Symmetrizing ' + self.plane2 + ' planes...')
+        for j in range(0, len(q2)):
+            print('Symmetrizing ' + q2.nxname + '=' + "{:.02f}".format(q2[j]) + "...", end='\r')
+            data_symmetrized = self.plane2symmetrizer.symmetrize_2d(
+                NXdata(NXfield(out_array[:, j, :], name=data.signal),
+                       (q1, q3)))
+            out_array[:, j, :] = data_symmetrized[data.signal].nxdata
+        print('\nSymmetrized ' + self.plane2 + ' planes.')
+
+        print('Symmetrizing ' + self.plane3 + ' planes...')
+        for i in range(0, len(q1)):
+            print('Symmetrizing ' + q1.nxname + '=' + "{:.02f}".format(q1[i]) + "...", end='\r')
+            data_symmetrized = self.plane3symmetrizer.symmetrize_2d(
+                NXdata(NXfield(out_array[i, :, :], name=data.signal),
+                       (q2, q3)))
+            out_array[i, :, :] = data_symmetrized[data.signal].nxdata
+        print('\nSymmetrized ' + self.plane3 + ' planes.')
+
+        out_array[out_array < 0] = 0
+
+        stoptime = time.time()
+        print("\nSymmetriztaion finished in " + "{:.02f}".format((stoptime - starttime) / 60) + " minutes.")
+
+        self.symmetrized = NXdata(NXfield(out_array, name=data.signal), tuple([data[axis] for axis in data.axes]))
+
+        return self.symmetrized
+
+    def save(self, fout_name=None):
+        """
+        Save the symmetrized dataset to a file.
+
+        Parameters
+        ----------
+        fout_name : str, optional
+            The name of the output file. If not provided, the default name 'symmetrized.nxs' will be used.
+
+        """
+        print("Saving file...")
+
+        f = NXroot()
+        f['entry'] = NXentry()
+        f['entry']['data'] = self.symmetrized
+        if fout_name is None:
+            fout_name = 'symmetrized.nxs'
+        nxsave(fout_name, f)
+        print("Output file saved to: " + os.path.join(os.getcwd(), fout_name))
+
 
-    # counts=counts.transpose()
-    
-    # Define Transformation
-    skew_angle_adj = 90-skew_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()
-    
-    # Calculate the angle for each data point
-    theta = np.arctan2(q1.reshape((-1, 1)), q2.reshape((1, -1)))
-
-    # Create a boolean array for the range of angles
-    symm_region = np.logical_and(theta >= theta_min*np.pi/180, theta <= theta_max*np.pi/180)
-    
-    # Calculate number of rotations needed to reconstruct the dataset
-    if mirror:
-        n_rots = abs(int(360/(theta_max-theta_min)/2))
-    else:
-        n_rots = abs(int(360/(theta_max-theta_min)))
-    
-    # Scale wedge to preserve norm after skewing
-    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,
-                                          )
-    wedge = ndimage.affine_transform(counts_skew,
-                                     Affine2D().scale(np.cos(skew_angle_adj*np.pi/180),1).get_matrix()[:2,:2],
-                                     offset=[(1-np.cos(skew_angle_adj*np.pi/180))*counts.shape[0]/2, 0],
-                                     order=0,
-                                    )*symm_region
-    
-    reconstruct = np.zeros(counts.shape)
-    for n in range(0,n_rots):
-        reconstruct += wedge
-        wedge = ndimage.rotate(wedge, 360/n_rots, reshape=False, order=0)
-    
-    if mirror:
-        reconstruct += np.flip(reconstruct, axis=0)
-
-    reconstruct = ndimage.affine_transform(reconstruct,
-                                           Affine2D().scale(np.cos(skew_angle_adj*np.pi/180), 1).inverted().get_matrix()[:2,:2],
-                                           offset=[-(1-np.cos(skew_angle_adj*np.pi/180))*counts.shape[0]/2/np.cos(skew_angle_adj*np.pi/180),0],
-                                           order=0,
-                                          )
-    reconstruct = ndimage.affine_transform(reconstruct,
-                                           t.get_matrix()[:2,:2],
-                                           offset=[(-counts.shape[0]/2*np.sin(skew_angle_adj*np.pi/180)),0],
-                                           order=0,
-                                          )
-    
-    return reconstruct
-    
+# class Puncher():
+#     pass
+#
+#
+# class Reducer():
+#     pass
+#
+#
+# class Interpolator():
+#     pass
+#
+#
+# class FourierTransformer():
+#     pass

{nxs_analysis_tools-0.0.18.dist-info → nxs_analysis_tools-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nxs-analysis-tools
-Version: 0.0.18
+Version: 0.0.20
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License

nxs_analysis_tools-0.0.20.dist-info/RECORD

@@ -0,0 +1,10 @@
+_meta/__init__.py,sha256=XSqHTz0m03EA_lG__7ugS0_aLOeAjpT3y0987MxmYIk,351
+nxs_analysis_tools/__init__.py,sha256=guRgN90Lv_DgQ-S7lKWLpFkglFvIJGoDcmQ_pjHVRw0,372
+nxs_analysis_tools/chess.py,sha256=OL-sQ8KZzY9393sWBDYxgpfkpcYhgtCJxonDML9Rwo4,9081
+nxs_analysis_tools/datareduction.py,sha256=nnxBaEWldzD0jbRRb04vBNZs_lPsGMBnjeVyvN7L33Y,20372
+nxs_analysis_tools/pairdistribution.py,sha256=LKHd2dVTMrBXItmtFBmYVAFjX1vK1vMeY8p2SN4UJdM,16692
+nxs_analysis_tools-0.0.20.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
+nxs_analysis_tools-0.0.20.dist-info/METADATA,sha256=kuXYBt8SKAXXroSf0X7f8nmtUM0zBCAaxIGxZWvTqLc,3844
+nxs_analysis_tools-0.0.20.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+nxs_analysis_tools-0.0.20.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
+nxs_analysis_tools-0.0.20.dist-info/RECORD,,

nxs_analysis_tools-0.0.18.dist-info/RECORD

@@ -1,10 +0,0 @@
-_meta/__init__.py,sha256=4lwV6pfk3hMrZLgiaTqjWQUGRJkD7gAe9lPSfuZx2d4,343
-nxs_analysis_tools/__init__.py,sha256=guRgN90Lv_DgQ-S7lKWLpFkglFvIJGoDcmQ_pjHVRw0,372
-nxs_analysis_tools/chess.py,sha256=A3z1Uxw4pCblZMTWUAMOGU2fRrAMKs1479zIxSA2t4k,7520
-nxs_analysis_tools/datareduction.py,sha256=vyufWH9HmjK_0saUvTVV5RpM2h9oLFoLPeB1UhRKuQ4,18581
-nxs_analysis_tools/pairdistribution.py,sha256=b4ZvS37OjzTKw8TfRByYYglE__95vD5XoCZfK7b2JRg,3748
-nxs_analysis_tools-0.0.18.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
-nxs_analysis_tools-0.0.18.dist-info/METADATA,sha256=O6wRnMtqzQyMK_XU6JElfSLi9v6aRiCLfDKagO0Tu20,3844
-nxs_analysis_tools-0.0.18.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-nxs_analysis_tools-0.0.18.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
-nxs_analysis_tools-0.0.18.dist-info/RECORD,,