nxs-analysis-tools 0.1.4__tar.gz → 0.1.6__tar.gz

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/PKG-INFO

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

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/pyproject.toml

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

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/_meta/__init__.py

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

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/nxs_analysis_tools/chess.py

@@ -14,6 +14,7 @@ from IPython.display import display, Markdown
 from nxs_analysis_tools import load_data, Scissors
 from nxs_analysis_tools.fitting import LinecutModel
 from nxs_analysis_tools.datareduction import load_transform, reciprocal_lattice_params
+from lmfit.models import PseudoVoigtModel, LinearModel
 
 
 class TempDependence:
@@ -98,7 +99,11 @@ class TempDependence:
         Fit the line cut models for each temperature.
     plot_fit(mdheadings=False, **kwargs):
         Plot the fit results for each temperature.
-    plot_order_parameter(self):
+    overlay_fits(numpoints=None, vertical_offset=0, cmap='viridis', ax=ax):
+        Plot raw data and fitted models for each temperature.
+    fit_peak_simple():
+        Perform a basic fit using a pseudo-Voigt peak shape, linear background, and no constraints.
+    plot_order_parameter():
         Plot the temperature dependence of the peakheight parameter.
     print_fit_report():
         Print the fit report for each temperature.
@@ -188,7 +193,7 @@ class TempDependence:
         """
         self.datasets[temperature] = data
 
-    def load_transforms(self, temperatures_list=None, print_tree=True):
+    def load_transforms(self, temperatures_list=None, print_tree=True, use_nxlink=False):
         """
         Load transform datasets (from nxrefine) based on temperature.
 
@@ -196,8 +201,14 @@ class TempDependence:
         ----------
         temperatures_list : list of int or None, optional
             List of temperatures to load. If None, all available temperatures are loaded.
+        
         print_tree : bool, optional
             Whether to print the data tree upon loading. Default True.
+        
+        use_nxlink : bool, optional
+            If True, maintains the NXlink defined in the data file, which references
+            the raw data in the transform.nxs file. This saves memory when working with
+            many datasets. In this case, the axes are in reverse order. Default is False.
         """
         # Convert all temperatures to strings
         if temperatures_list:
@@ -240,7 +251,7 @@ class TempDependence:
 
             # Save dataset
             try:
-                self.datasets[self.temperatures[i]] = load_transform(path, print_tree)
+                self.datasets[self.temperatures[i]] = load_transform(path, print_tree=print_tree, use_nxlink=use_nxlink)
             except Exception as e:
                 # Report temperature that was unable to load, then raise exception.
                 temp_failed = self.temperatures[i]
@@ -463,7 +474,7 @@ class TempDependence:
         y = np.array([int(t) for t in self.temperatures])
 
         # Collect counts from each temperature and ensure they are numpy arrays
-        v = [self.linecuts[T].counts.nxdata for T in self.temperatures]
+        v = [self.linecuts[T].nxsignal.nxdata for T in self.temperatures]
 
         # Convert list of arrays to a 2D array for the heatmap
         v_2d = np.array(v)
@@ -542,7 +553,7 @@ class TempDependence:
 
         Parameters
         ----------
-        model_components : Model or iterable of Model
+        model_components : Model, CompositeModel, or iterable of Model
             The model components to set for all line cut models.
 
         """
@@ -555,7 +566,8 @@ class TempDependence:
 
         This method sets the parameter hints for all line cut models in the analysis.
         It iterates over each line cut model and calls their respective `set_param_hint` method
-        with the provided arguments and keyword arguments.
+        with the provided arguments and keyword arguments. These are implemented when the
+        .make_params() method is called.
 
         Parameters
         ----------
@@ -567,10 +579,40 @@ class TempDependence:
         """
         [linecutmodel.set_param_hint(*args, **kwargs)
          for linecutmodel in self.linecutmodels.values()]
+    
+    def params_set(self, name, **kwargs):
+        """
+        Set constraints on a parameter for all line cut models.
+
+        This method updates the specified parameter across all models in
+        `self.linecutmodels` using the keyword arguments provided. These
+        keyword arguments are passed to the `set()` method of the parameter,
+        which comes from a `lmfit.Parameters` object.
+
+        Parameters
+        ----------
+        name : str
+            Name of the parameter to modify (must exist in each model).
+        **kwargs
+            Constraint arguments passed to `Parameter.set()`, such as `value`,
+            `min`, `max`, `vary`, etc.
+
+        Raises
+        ------
+        KeyError
+            If the parameter `name` does not exist in one of the models.
+
+        Example
+        -------
+        >>> sample.params_set('peakamplitude', value=5, min=0, vary=True)
+        """
+
+        for linecutmodel in self.linecutmodels.values():
+            linecutmodel.params[name].set(**kwargs)
 
     def make_params(self):
         """
-        Make parameters for all line cut models.
+        Create and initialize the parameters for all models.
 
         This method creates the parameters for all line cut models in the analysis.
         It iterates over each line cut model and calls their respective `make_params` method.
@@ -579,7 +621,8 @@ class TempDependence:
 
     def guess(self):
         """
-        Make initial parameter guesses for all line cut models.
+        Make initial parameter guesses for all line cut models. This overwrites any prior initial
+        values and constraints.
 
         This method generates initial parameter guesses for all line cut models in the analysis.
         It iterates over each line cut model and calls their respective `guess` method.
@@ -651,6 +694,68 @@ class TempDependence:
                                   title=f"{T} K",
                                   **kwargs)
 
+    def overlay_fits(self, numpoints=None, vertical_offset=0, cmap='viridis', ax=None):
+        """
+        Plot raw data and fitted models for each temperature with optional vertical offsets.
+
+        Parameters:
+        -----------
+        numpoints : int or None, default=None
+            Number of points to evaluate for the fitted model curves.
+            If None, uses the number of raw data points for each linecut.
+        vertical_offset : float, default=0
+            Amount to vertically offset each linecut for clarity.
+        cmap : str, default='viridis'
+            Name of the matplotlib colormap used to distinguish different temperatures.
+        ax : matplotlib.axes.Axes or None, default=None
+            Axis object to plot on. If None, a new figure and axis are created.
+
+        The function:
+        - Uses a colormap to assign unique colors to each temperature.
+        - Plots raw data alongside evaluated fit models for each linecut.
+        - Vertically offsets each trace by a constant value for visual separation.
+        - Displays a legend in reverse order to match top-to-bottom visual stacking.
+        - Automatically labels the x- and y-axes based on NeXus-style data metadata.
+        """
+
+        # Create a figure and axes if an axis is not already provided
+        _, ax = plt.subplots() if ax is None else (None, ax)
+
+        # Generate a color palette for the various temperatures
+        cmap = plt.get_cmap(cmap)
+        colors = [cmap(i / len(self.temperatures)) for i, _ in enumerate(self.temperatures)]
+
+        for i, lm in enumerate(self.linecutmodels.values()):
+            # Plot the raw data
+            ax.plot(lm.x, lm.y + vertical_offset * i, '.', c=colors[i])
+
+            # Evaluate the fit
+            numpoints = len(lm.x) if numpoints is None else numpoints
+            x_eval = np.linspace(lm.x.min(), lm.x.max(), numpoints)
+            y_eval = lm.modelresult.eval(x=x_eval)
+            ax.plot(x_eval, y_eval + vertical_offset * i, '-', c=colors[i], label=self.temperatures[i])
+
+        # Reverse legend entries to match top-to-bottom stacking
+        handles, labels = ax.get_legend_handles_labels()
+        ax.legend(handles[::-1], labels[::-1])
+
+        # Add axis labels
+        ax.set(xlabel=lm.data.nxaxes[0].nxname, ylabel=lm.data.nxsignal.nxname)
+        
+    def fit_peak_simple(self):
+        """
+        Fit all linecuts in the temperature series using a pseudo-Voigt peak shape and linear
+        background, with no constraints.
+        """
+
+        for T in self.temperatures:
+            linecutmodel = self.linecutmodels[T]
+            linecutmodel.set_model_components([PseudoVoigtModel(prefix='peak'),
+                                                LinearModel(prefix='background')])
+            linecutmodel.make_params()
+            linecutmodel.guess()
+            linecutmodel.fit()
+
     def plot_order_parameter(self):
         """
         Plot the temperature dependence of the peak height (order parameter).

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/nxs_analysis_tools/datareduction.py

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

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/nxs_analysis_tools/fitting.py

@@ -3,8 +3,9 @@ Module for fitting of linecuts using the lmfit package.
 """
 
 import operator
-from lmfit.model import Model
-from lmfit.model import CompositeModel
+from lmfit import Parameters
+from lmfit.model import Model, CompositeModel
+from lmfit.models import PseudoVoigtModel, LinearModel
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -66,6 +67,8 @@ class LinecutModel:
         Fit the model to the data.
     plot_fit(self, numpoints=None, fit_report=True, **kwargs)
         Plot the fitted model.
+    fit_peak_simple():
+        Perform a basic fit using a pseudo-Voigt peak shape, linear background, and no constraints.
     print_fit_report(self)
         Print the fit report.
     """
@@ -110,15 +113,25 @@ class LinecutModel:
 
         Parameters
         ----------
-        model_components : Model or list of Models
-            The model component(s) to be used for fitting,
-             which will be combined into a CompositeModel.
+        model_components : Model, CompositeModel, or iterable of Model
+            The model component(s) to be used for fitting.
         """
 
         # If the model only has one component, then use it as the model
         if isinstance(model_components, Model):
             self.model = model_components
-        # Else, combine the components into a composite model and use that as the
+            self.params = self.model.make_params()
+
+        # If the model is a composite model, then use it as the model
+        elif isinstance(model_components, CompositeModel):
+            self.model = model_components
+            self.model_components = self.model.components
+            # Make params for each component of the model
+            self.params = Parameters()
+            for component in self.model.components:
+                self.params.update(component.make_params())
+
+        # Else, combine the components into a composite model and use that as the model
         else:
             self.model_components = model_components
             self.model = model_components[0]
@@ -127,9 +140,15 @@ class LinecutModel:
             for component in model_components[1:]:
                 self.model = CompositeModel(self.model, component, operator.add)
 
+            # Make params for each component of the model
+            self.params = Parameters()
+            for component in self.model.components:
+                self.params.update(component.make_params())
+
     def set_param_hint(self, *args, **kwargs):
         """
-        Set parameter hints for the model.
+        Set parameter hints for the model. These are implemented when the .make_params() method
+        is called.
 
         Parameters
         ----------
@@ -159,10 +178,22 @@ class LinecutModel:
 
     def guess(self):
         """
-        Perform initial guesses for each model component.
+        Perform initial guesses for each model component and update params. This overwrites any
+        prior initial values and constraints.
+
+        Returns
+        -------
+        components_params : list
+            A list containing params objects for each component of the model.
         """
-        for model_component in list(self.model_components):
+        
+        components_params = []
+        
+        for model_component in self.model.components:
             self.params.update(model_component.guess(self.y, x=self.x))
+            components_params.append(model_component.guess(self.y, x=self.x))
+        
+        return components_params
 
     def print_initial_params(self):
         """
@@ -251,6 +282,17 @@ class LinecutModel:
         if fit_report:
             print(self.modelresult.fit_report())
         return ax
+    
+    def fit_peak_simple(self):
+        """
+        Fit all linecuts in the temperature series using a pseudo-Voigt peak shape and linear
+        background, with no constraints.
+        """
+        self.set_model_components([PseudoVoigtModel(prefix='peak'),
+                                            LinearModel(prefix='background')])
+        self.make_params()
+        self.guess()
+        self.fit()
 
     def print_fit_report(self):
         """

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/nxs_analysis_tools/pairdistribution.py

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

{nxs_analysis_tools-0.1.4 → nxs_analysis_tools-0.1.6}/src/nxs_analysis_tools.egg-info/SOURCES.txt

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

nxs_analysis_tools-0.1.6/tests/test_ellipsoidal_window.py

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

nxs_analysis_tools-0.1.6/tests/test_plot_slice_axes_types.py

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