nxs-analysis-tools 0.0.23__py3-none-any.whl → 0.0.25__py3-none-any.whl

_meta/__init__.py

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

nxs_analysis_tools/__init__.py

@@ -4,9 +4,9 @@ Reduce and transform nexus format (.nxs) scattering data.
 
 import numpy as np
 from _meta import __author__, __copyright__, __license__, __version__
-from .datareduction import load_data, plot_slice, Scissors, reciprocal_lattice_params
+from .datareduction import load_data, plot_slice, reciprocal_lattice_params, Scissors, rotate_data
 from .chess import TempDependence
 
 # What to import when running "from nxs_analysis_tools import *"
 __all__ = ['load_data', 'plot_slice', 'Scissors', 'TempDependence',
-           'reciprocal_lattice_params']
+           'reciprocal_lattice_params', 'rotate_data']

nxs_analysis_tools/datareduction.py

@@ -1,7 +1,7 @@
 """
 Reduces scattering data into 2D and 1D datasets.
 """
-
+import os
 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib.transforms import Affine2D
@@ -10,9 +10,11 @@ from matplotlib.ticker import MultipleLocator
 from matplotlib import colors
 from matplotlib import patches
 from IPython.display import display, Markdown
-from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError
+from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXentry, nxsave
+from scipy import ndimage
 
-__all__ = ['load_data', 'plot_slice', 'Scissors']
+# Specify items on which users are allowed to perform standalone imports
+__all__ = ['load_data', 'plot_slice', 'Scissors', 'reciprocal_lattice_params', 'rotate_data', 'array_to_nxdata', 'Padder']
 
 
 def load_data(path):
@@ -39,6 +41,31 @@ def load_data(path):
     return g.entry.data
 
 
+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.
+
+    Parameters
+    ----------
+    array : array-like
+        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.
+
+    signal_name : str, optional
+        The name of the signal within the NXdata object. If not provided,
+        the default signal name 'counts' is used.
+
+    Returns
+    -------
+    NXdata
+        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))]))
+
+
 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,
@@ -113,7 +140,6 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
 
     """
     if type(data) == np.ndarray:
-        data = data.transpose()
         if X is None:
             X = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='x')
         if Y is None:
@@ -121,7 +147,8 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
         if transpose:
             X, Y = Y, X
             data = data.transpose()
-        data = NXdata(NXfield(data, name='value'), (X,Y))
+        data = NXdata(NXfield(data, name='value'), (X, Y))
+        data_arr = data
     elif type(data) == NXdata or type(data) == NXfield:
         if X is None:
             X = data[data.axes[0]]
@@ -130,11 +157,10 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
         if transpose:
             X, Y = Y, X
             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.")
 
-    data_arr = data[data.signal].nxdata.transpose()
-
     # Display Markdown heading
     if mdheading is None:
         pass
@@ -171,15 +197,15 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
 
     ## Transform data to new coordinate system if necessary
     # Correct skew angle
-    skew_angle = 90 - 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 * np.pi / 180))
+    t += Affine2D().scale(1, np.cos(skew_angle_adj * np.pi / 180))
     # Shear along x-axis
-    t += Affine2D().skew_deg(skew_angle, 0)
+    t += Affine2D().skew_deg(skew_angle_adj, 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_adj * np.pi / 180)).inverted()
     ## Correct for x-displacement after shearing
     # If ylims provided, use those
     if ylim is not None:
@@ -190,17 +216,20 @@ 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 * 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:
         xmin, xmax = xlim
     else:
         xmin, xmax = ax.get_xlim()
-    ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - skew_angle) * np.pi / 180)))
+    if skew_angle <= 90:
+        ax.set(xlim=(xmin, xmax + (ymax - ymin) / np.tan((90 - skew_angle_adj) * np.pi / 180)))
+    else:
+        ax.set(xlim=(xmin - (ymax - ymin) / np.tan((skew_angle_adj - 90) * np.pi / 180), xmax))
 
     # 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_adj * np.pi / 180))
 
     # Add tick marks all around
     ax.tick_params(direction='in', top=True, right=True, which='both')
@@ -228,7 +257,7 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
         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_adj, 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) +
@@ -238,7 +267,7 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
             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_adj, 0))
 
         line.set_marker(m)
 
@@ -246,9 +275,9 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None, skew
         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))
+            m._transform.set(Affine2D().translate(0, -1) + Affine2D().skew_deg(skew_angle_adj, 0))
         else:
-            m._transform.set(Affine2D().skew_deg(skew_angle, 0))
+            m._transform.set(Affine2D().skew_deg(skew_angle_adj, 0))
 
         line.set_marker(m)
 
@@ -624,3 +653,227 @@ def reciprocal_lattice_params(lattice_params):
     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
+
+
+def rotate_data(data, lattice_angle, rotation_angle, rotation_axis):
+    """
+    Rotates 3D data around a specified axis.
+
+    Parameters
+    ----------
+    data : :class:`nexusformat.nexus.NXdata`
+        Input data.
+    lattice_angle : float
+        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).
+
+    Returns
+    -------
+    rotated_data : :class:`nexusformat.nexus.NXdata`
+        Rotated data as an NXdata object.
+    """
+    # Define output array
+    output_array = np.zeros(data[data.signal].shape)
+
+    # 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()
+
+    for i in range(len(data[data.axes[rotation_axis]])):
+        # 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
+
+        p = Padder(sliced_data)
+        padding = tuple([len(sliced_data[axis]) for axis in sliced_data.axes])
+        counts = p.pad(padding)
+
+        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,
+                                                 )
+        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,
+                                                  )
+        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,
+                                                  )
+
+        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],
+                                                    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],
+                                                    offset=[-(1 - scale1) * counts.shape[
+                                                        0] / 2 / scale1, 0],
+                                                    order=0,
+                                                    )
+
+        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_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
+
+    return NXdata(NXfield(output_array, name='counts'),
+                  (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
+
+
+class Padder():
+    """
+    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.
+
+        """
+        self.padded = None
+        self.padding = None
+        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):
+        """
+        Removes the padded region from the data.
+
+        Parameters
+        ----------
+        data : ndarray or NXdata
+            The padded data from which to remove the padding.
+
+        Returns
+        -------
+        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]

nxs_analysis_tools/pairdistribution.py

@@ -8,128 +8,7 @@ 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, reciprocal_lattice_params
-
-
-
-class Padder():
-    """
-    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.
-
-        """
-        self.padded = None
-        self.padding = None
-        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):
-        """
-        Removes the padded region from the data.
-
-        Parameters
-        ----------
-        data : ndarray or NXdata
-            The padded data from which to remove the padding.
-
-        Returns
-        -------
-        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]
-
+from .datareduction import plot_slice, reciprocal_lattice_params, Padder
 
 class Symmetrizer2D:
     """
@@ -185,7 +64,7 @@ class Symmetrizer2D:
         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
+        # Calculate number of rotations needed to reconstruct the dataset
         if mirror:
             rotations = abs(int(360 / (theta_max - theta_min) / 2))
         else:
@@ -368,24 +247,53 @@ class Symmetrizer3D:
     A class to symmetrize 3D datasets.
     """
 
-    def __init__(self, data):
+    def __init__(self, data=None):
         """
         Initialize the Symmetrizer3D object.
 
         Parameters
         ----------
-        data : NXdata
+        data : NXdata, optional
             The input 3D dataset to be symmetrized.
 
         """
+
+        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
+        self.lattice_params = None
+        self.reciprocal_lattice_params = None
         self.symmetrized = None
         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()
+
+        if data is not None:
+            self.q1 = data[data.axes[0]]
+            self.q2 = data[data.axes[1]]
+            self.q3 = data[data.axes[2]]
+            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 set_data(self, data):
+        """
+        Sets the data to be symmetrized.
+
+        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.plane1 = self.q1.nxname + self.q2.nxname
         self.plane2 = self.q1.nxname + self.q3.nxname
         self.plane3 = self.q2.nxname + self.q3.nxname
@@ -394,6 +302,12 @@ class Symmetrizer3D:
         print("Plane 2: " + self.plane2)
         print("Plane 3: " + self.plane3)
 
+    def set_lattice_params(self, lattice_params):
+        self.a, self.b, self.c, self.al, self.be, self.ga = lattice_params
+        self.lattice_params = lattice_params
+        self.reciprocal_lattice_params = reciprocal_lattice_params(lattice_params)
+        self.a_star, self.b_star, self.c_star, self.al_star, self.be_star, self.ga_star = self.reciprocal_lattice_params
+
     def symmetrize(self):
         """
         Perform the symmetrization of the 3D dataset.
@@ -491,7 +405,7 @@ def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None):
         coeffs = [1, 0, 1, 0, 1, 0]
     a, b, c, al, be, ga = lattice_params
     a_, b_, c_, al_, be_, ga_ = reciprocal_lattice_params((a, b, c, al, be, ga))
-    H, K, L = np.meshgrid(H, K, L)
+    H, K, L = np.meshgrid(H, K, L, indexing='ij')
     gaussian = amp * np.exp(-(coeffs[0] * H ** 2 +
                               coeffs[1] * (b_ * a_ / (a_ ** 2)) * H * K +
                               coeffs[2] * (b_ / a_) ** 2 * K ** 2 +
@@ -502,16 +416,25 @@ def generate_gaussian(H, K, L, amp, stddev, lattice_params, coeffs=None):
         gaussian = gaussian.transpose(1, 0, 2)
     elif gaussian.ndim == 2:
         gaussian = gaussian.transpose()
-    return gaussian.transpose(1,0,2)
+    return gaussian.transpose(1, 0, 2)
 
 
 class Puncher:
     def __init__(self):
+        self.punched = None
+        self.data = None
+        self.H, self.K, self.L = [None] * 3
         self.mask = None
+        self.reciprocal_lattice_params = None
+        self.lattice_params = None
         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
 
     def set_data(self, data):
         self.data = data
+        if self.mask is None:
+            self.mask = np.zeros(data[data.signal].nxdata.shape)
+        self.H, self.K, self.L = np.meshgrid(data[data.axes[0]], data[data.axes[1]], data[data.axes[2]], indexing='ij')
 
     def set_lattice_params(self, lattice_params):
         self.a, self.b, self.c, self.al, self.be, self.ga = lattice_params
@@ -519,53 +442,18 @@ class Puncher:
         self.reciprocal_lattice_params = reciprocal_lattice_params(lattice_params)
         self.a_star, self.b_star, self.c_star, self.al_star, self.be_star, self.ga_star = self.reciprocal_lattice_params
 
+    def add_mask(self, maskaddition):
+        self.mask = np.logical_or(self.mask, maskaddition)
 
-    def set_gaussian_background(self, amp, stddev, coeffs=None):
-        if coeffs is None:
-            coeffs = [1, 0, 1, 0, 1, 0]
-        data = self.data
-        self.background = generate_gaussian(data[data.axes[0]], data[data.axes[1]], data[data.axes[2]],
-                                            amp=amp, stddev=stddev, lattice_params=self.lattice_params,
-                                            coeffs=coeffs)
-
-    def plot_gaussian_background(self):
-        data = self.data
-        fig, axes = plt.subplots(1, 3)
-        # Plot the background and subtracted
-        plot_slice(self.background[:, :, len(data[data.axes[2]]) // 2], data[data.axes[0]], data[data.axes[1]],
-                   ax=axes[0], skew_angle=self.ga_star)
-        plot_slice(self.background[:, len(data[data.axes[1]]) // 2, :],data[data.axes[0]], data[data.axes[2]],
-                   ax=axes[1], skew_angle=self.be_star)
-        plot_slice(self.background[len(data[data.axes[0]]) // 2, :, :],data[data.axes[1]], data[data.axes[2]],
-                   ax=axes[2], skew_angle=self.al_star)
-        plt.show()
-        return fig, axes
+    def subtract_mask(self, masksubtraction):
+        self.mask = np.logical_and(self.mask, np.logical_not(masksubtraction))
 
-    def plot_background_subtraction(self, **kwargs):
-        data = self.data
-        fig, axes = plt.subplots(1, 3, figsize=(10,3))
-        # Plot the background and subtracted
-        plot_slice(data[data.signal][:, :, 0.0] - self.background[:, :, len(data[data.axes[2]]) // 2],
-                   data[data.axes[0]], data[data.axes[1]],
-                   ax=axes[0], skew_angle=self.ga_star, **kwargs)
-        plot_slice(data[data.signal][:, 0.0, :] - self.background[:, len(data[data.axes[1]]) // 2, :],
-                   data[data.axes[0]], data[data.axes[2]],
-                   ax=axes[1], skew_angle=self.be_star, **kwargs)
-        plot_slice(data[data.signal][0.0, :, :] - self.background[len(data[data.axes[0]]) // 2, :, :],
-                   data[data.axes[1]], data[data.axes[2]],
-                   ax=axes[2], skew_angle=self.al_star, **kwargs)
-        plt.show()
-        return fig, axes
-
-    def generate_mask(self, punch_radius, coeffs=None, thresh=None):
+    def generate_bragg_mask(self, punch_radius, coeffs=None, thresh=None):
         if coeffs is None:
             coeffs = [1, 0, 1, 0, 1, 0]
         data = self.data
-        lattice_params = self.lattice_params
-        a, b, c, al, be, ga = lattice_params
-        a_, b_, c_, al_, be_, ga_ = reciprocal_lattice_params((a, b, c, al, be, ga))
-
-        H, K, L = np.meshgrid(data[data.axes[0]], data[data.axes[1]], data[data.axes[2]])
+        H, K, L = self.H, self.K, self.L
+        a_, b_, c_, al_, be_, ga_ = self.reciprocal_lattice_params
 
         mask = (coeffs[0] * (H - np.rint(H)) ** 2 +
                 coeffs[1] * (b_ * a_ / (a_ ** 2)) * (H - np.rint(H)) * (K - np.rint(K)) +
@@ -577,19 +465,51 @@ class Puncher:
         if thresh:
             mask = np.logical_and(mask, data[data.signal] > thresh)
 
-        self.mask = mask
+        return mask
+
+    def generate_mask_at_coord(self, coordinate, punch_radius, coeffs=None, thresh=None):
+        if coeffs is None:
+            coeffs = [1, 0, 1, 0, 1, 0]
+        data = self.data
+        H, K, L = self.H, self.K, self.L
+        a_, b_, c_, al_, be_, ga_ = self.reciprocal_lattice_params
+        centerH, centerK, centerL = coordinate
+        mask = (coeffs[0] * (H - centerH) ** 2 +
+                coeffs[1] * (b_ * a_ / (a_ ** 2)) * (H - centerH) * (K - centerK) +
+                coeffs[2] * (b_ / a_) ** 2 * (K - centerK) ** 2 +
+                coeffs[3] * (b_ * c_ / (a_ ** 2)) * (K - centerK) * (L - centerL) +
+                coeffs[4] * (c_ / a_) ** 2 * (L - centerL) ** 2 +
+                coeffs[5] * (c_ * a_ / (a_ ** 2)) * (L - centerL) * (H - centerH)) < punch_radius ** 2
+
+        if thresh:
+            mask = np.logical_and(mask, data[data.signal] > thresh)
 
         return mask
 
+    def punch(self):
+        data= self.data
+        self.punched = NXdata(NXfield(np.where(self.mask, np.nan, data[data.signal].nxdata), name=data.signal),
+                              (data[data.axes[0]],data[data.axes[1]],data[data.axes[2]]))
+        return self.punched
 
 
 # class Reducer():
 #     pass
 #
 #
-# class Interpolator():
-#     pass
-#
-#
-# class FourierTransformer():
-#     pass
+
+class Interpolator():
+    def __init__(self):
+        self.data = None
+
+    def set_data(self, data):
+        self.data = data
+
+    def set_kernel(self, kernel):
+        self.kernel = kernel
+
+    def generate_gaussian_kernel(self, amp, stddev, coeffs=None):
+        pass
+
+    def interpolate(self):
+        pass

{nxs_analysis_tools-0.0.23.dist-info → nxs_analysis_tools-0.0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nxs-analysis-tools
-Version: 0.0.23
+Version: 0.0.25
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License
@@ -42,27 +42,27 @@ Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: matplotlib (>=3.7.1)
-Requires-Dist: numpy (>=1.24.3)
-Requires-Dist: ipython (>=1.0.0)
-Requires-Dist: pandas (>=2.0.2)
-Requires-Dist: nexusformat (>=1.0.1)
-Requires-Dist: lmfit (>=1.2.1)
+Requires-Dist: matplotlib >=3.7.1
+Requires-Dist: numpy >=1.24.3
+Requires-Dist: ipython >=1.0.0
+Requires-Dist: pandas >=2.0.2
+Requires-Dist: nexusformat >=1.0.1
+Requires-Dist: lmfit >=1.2.1
 Provides-Extra: dev
-Requires-Dist: build (>=0.8.0) ; extra == 'dev'
-Requires-Dist: furo (>=2022.6.21) ; extra == 'dev'
-Requires-Dist: ipykernel (>=6.9.1) ; extra == 'dev'
-Requires-Dist: myst-nb (>=0.16.0) ; extra == 'dev'
-Requires-Dist: myst-parser (>=0.18.0) ; extra == 'dev'
-Requires-Dist: numpydoc (>=1.4.0) ; extra == 'dev'
-Requires-Dist: pandoc (>=2.2) ; extra == 'dev'
-Requires-Dist: pylint (>=2.12.2) ; extra == 'dev'
-Requires-Dist: pytest (>=7.1.2) ; extra == 'dev'
-Requires-Dist: sphinx (>=5.0.2) ; extra == 'dev'
-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: build >=0.8.0 ; extra == 'dev'
+Requires-Dist: furo >=2022.6.21 ; extra == 'dev'
+Requires-Dist: ipykernel >=6.9.1 ; extra == 'dev'
+Requires-Dist: myst-nb >=0.16.0 ; extra == 'dev'
+Requires-Dist: myst-parser >=0.18.0 ; extra == 'dev'
+Requires-Dist: numpydoc >=1.4.0 ; extra == 'dev'
+Requires-Dist: pandoc >=2.2 ; extra == 'dev'
+Requires-Dist: pylint >=2.12.2 ; extra == 'dev'
+Requires-Dist: pytest >=7.1.2 ; extra == 'dev'
+Requires-Dist: sphinx >=5.0.2 ; extra == 'dev'
+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'
 
 # nxs-analysis-tools
 

nxs_analysis_tools-0.0.25.dist-info/RECORD

@@ -0,0 +1,11 @@
+_meta/__init__.py,sha256=7cJjLXTZ19DjCsiIgJYt59ddCxaAy7fKcbVw6mC6zNQ,351
+nxs_analysis_tools/__init__.py,sha256=HAdFMaImTfd2nCP1XzeSwreAv-wK6CeJbTn92aDQ-Bc,490
+nxs_analysis_tools/chess.py,sha256=tNWc5xiwEjdtVPq0FFm2dCP2xvtkuv4IkMLur7Qeqjs,14079
+nxs_analysis_tools/datareduction.py,sha256=lBydXjACptm8WHlO3knZP-ridjorPuoW_sqe7Bip73s,32112
+nxs_analysis_tools/fitting.py,sha256=f0wUn2uLwT6a2Yg8QgzzSdR0zgqjjeNMj-H_HJh7D6o,8888
+nxs_analysis_tools/pairdistribution.py,sha256=-_ULgC1XA9UKposzk51-64Y3cPWqdnBNAK7sdVTGHXM,20972
+nxs_analysis_tools-0.0.25.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
+nxs_analysis_tools-0.0.25.dist-info/METADATA,sha256=2o3IJevdoU9hoWwkIMens_mXpWxNrJSdX2DXnLzysG8,3837
+nxs_analysis_tools-0.0.25.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+nxs_analysis_tools-0.0.25.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
+nxs_analysis_tools-0.0.25.dist-info/RECORD,,

{nxs_analysis_tools-0.0.23.dist-info → nxs_analysis_tools-0.0.25.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nxs_analysis_tools-0.0.23.dist-info/RECORD

@@ -1,11 +0,0 @@
-_meta/__init__.py,sha256=IfDXCuKvuNWLFdLhpE9vE-4teC25IyL7gxQBBKNmGS8,351
-nxs_analysis_tools/__init__.py,sha256=76pZHRU38bcY1EENxK2CEfWJC_hcwU2KH8om_FTuPN0,462
-nxs_analysis_tools/chess.py,sha256=tNWc5xiwEjdtVPq0FFm2dCP2xvtkuv4IkMLur7Qeqjs,14079
-nxs_analysis_tools/datareduction.py,sha256=XGlAgKavKE_XNo5oABXydI8Xie7OmXOvrRUEgkI9WS4,22110
-nxs_analysis_tools/fitting.py,sha256=f0wUn2uLwT6a2Yg8QgzzSdR0zgqjjeNMj-H_HJh7D6o,8888
-nxs_analysis_tools/pairdistribution.py,sha256=3_Lyg0iuajzUmGppzs48pdGvcjpiDGCURn4bxPtoijY,23475
-nxs_analysis_tools-0.0.23.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
-nxs_analysis_tools-0.0.23.dist-info/METADATA,sha256=DFiPw9Jg1CMgd67TLcktZcTX4oMVPVwMEiKLJyKEXYI,3877
-nxs_analysis_tools-0.0.23.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-nxs_analysis_tools-0.0.23.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
-nxs_analysis_tools-0.0.23.dist-info/RECORD,,