nxs-analysis-tools 0.1.5__tar.gz → 0.1.7__tar.gz

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/PKG-INFO

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

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.1.5'
+version = '0.1.7'
 description = 'Reduce and transform nexus format (.nxs) scattering data.'
 readme = 'README.md'
 requires-python = '>=3.7'
@@ -71,7 +71,7 @@ dev = [
 'DOI' = 'https://doi.org/10.5281/zenodo.15186359'
 
 [tool.bumpver]
-current_version = "0.1.5"
+current_version = "0.1.7"
 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.5 → nxs_analysis_tools-0.1.7}/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.5'
+__version__ = '0.1.7'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/src/nxs_analysis_tools/__init__.py

@@ -11,4 +11,5 @@ from .chess import TempDependence
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
            'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
-           'rebin_nxdata', 'rebin_3d', 'rebin_1d'] + ['TempDependence']
+           'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'TempDependence',
+           'animate_slice_temp', 'animate_slice_axis']

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/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,18 +99,32 @@ 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(ax, **kwargs):
         Plot the temperature dependence of the peakheight parameter.
     print_fit_report():
         Print the fit report for each temperature.
     """
 
-    def __init__(self):
+    def __init__(self, sample_directory=None):
         """
-        Initialize the TempDependence class with default values.
+        Initialize the TempDependence class.
+
+        Parameters
+        ----------
+        sample_directory : str, optional
+            Path to the directory containing the temperature folders.
+            If None, no directory is set initially.
         """
 
-        self.sample_directory = None
+        if sample_directory is None:
+            self.sample_directory = None
+        else:
+            self.set_sample_directory(sample_directory)
+
         self.xlabel = ''
         self.datasets = {}
         self.temperatures = []
@@ -133,7 +148,7 @@ class TempDependence:
 
     def find_temperatures(self):
         """
-        Set the list of temperatures by automatically scanning the sample directory.
+        Set the list of temperatures by automatically scanning the sample directory for .nxs files from nxrefine.
         """
 
         # Assert that self.sample_directory must exist
@@ -449,7 +464,7 @@ class TempDependence:
 
         Parameters
         ----------
-        ax : matplotlib.axes.Axes, optional
+        ax : :class:`matplotlib.axes.Axes`, optional
             The axes on which to plot the heatmap. If None, a new figure and axes
             are created. The default is None.
         **kwargs
@@ -469,7 +484,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)
@@ -548,7 +563,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.
 
         """
@@ -561,7 +576,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
         ----------
@@ -573,10 +589,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.
@@ -585,7 +631,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.
@@ -657,7 +704,70 @@ class TempDependence:
                                   title=f"{T} K",
                                   **kwargs)
 
-    def plot_order_parameter(self):
+    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 : :class:`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.params.set('peakamplitude', min=0)
+            linecutmodel.fit()
+
+    def plot_order_parameter(self, ax=None, **kwargs):
         """
         Plot the temperature dependence of the peak height (order parameter).
 
@@ -665,6 +775,14 @@ class TempDependence:
         line cut fit stored in `linecutmodels` and plots it as a function
         of temperature using matplotlib.
 
+        Parameters
+        ----------
+        ax : :class:`matplotlib.axes.Axes`, optional
+            Axis object to plot on. If None, a new figure and axis are created.
+        **kwargs
+            Keyword arguments to be passed to the plot function.
+
+
         Returns
         -------
         Figure
@@ -687,11 +805,19 @@ class TempDependence:
 
         # Extract the peakheight at every temperature
         for T in self.temperatures:
+            
+            # Verify that the fit has already been completed
+            if self.linecutmodels[T].modelresult is None:
+                raise AttributeError("Model result is empty. Have you fit the data to a model?")
+            
             peakheights.append(self.linecutmodels[T].modelresult.params['peakheight'].value)
 
         # Plot the peakheights vs. temperature
-        fig, ax = plt.subplots()
-        ax.plot(temperatures, peakheights)
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+        ax.plot(temperatures, peakheights, **kwargs)
         ax.set(xlabel='$T$ (K)', ylabel='peakheight')
         return fig, ax
 

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/src/nxs_analysis_tools/datareduction.py

@@ -2,22 +2,27 @@
 Reduces scattering data into 2D and 1D datasets.
 """
 import os
+import io
+import warnings
 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib.transforms import Affine2D
 from matplotlib.markers import MarkerStyle
 from matplotlib.ticker import MultipleLocator
+import matplotlib.animation as animation
 from matplotlib import colors
 from matplotlib import patches
-from IPython.display import display, Markdown
+from IPython.display import display, Markdown, HTML, Image
 from nexusformat.nexus import NXfield, NXdata, nxload, NeXusError, NXroot, NXentry, nxsave
 from scipy import ndimage
 
+
 # Specify items on which users are allowed to perform standalone imports
 __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
            'reciprocal_lattice_params', 'rotate_data', 'rotate_data_2D',
            'convert_to_inverse_angstroms', 'array_to_nxdata', 'Padder',
-           'rebin_nxdata', 'rebin_3d', 'rebin_1d']
+           'rebin_nxdata', 'rebin_3d', 'rebin_1d', 'animate_slice_temp',
+           'animate_slice_axis']
 
 
 def load_data(path, print_tree=True):
@@ -407,6 +412,9 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
             # Use the 2D template to create a new nxdata
             data = array_to_nxdata(arr, data[slice_obj])
 
+    if data.ndim != 2:
+        raise ValueError("Slice data must be 2D.")
+
     # If the data is of type ndarray, then convert to NXdata
     if is_array:
         # Convert X to NXfield if it is not already
@@ -600,6 +608,175 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
     # Return the quadmesh object
     return p
 
+def animate_slice_temp(temp_dependence, slice_obj, ax=None, interval=500, save_gif=False, filename='animation',
+                       title=True, title_fmt='d', plot_slice_kwargs=None, ax_kwargs=None):
+    """
+    Animate 2D slices from a temperature-dependent dataset.
+
+    Creates a matplotlib animation by extracting 2D slices from each dataset 
+    in a TempDependence object and animating them in sequence by temperature.
+    Optionally displays the animation inline and/or saves it as a GIF.
+
+    Parameters
+    ----------
+    temp_dependence : nxs_analysis_tools.chess.TempDependence
+        Object holding datasets at various temperatures.
+    slice_obj : list of slice or None
+        Slice object to apply to each dataset; None entries are treated as ':'.
+    ax : matplotlib.axes.Axes, optional
+        The axes object to plot on. If None, a new figure and axes will be created.
+    interval : int, optional
+        Delay between frames in milliseconds. Default is 500.
+    save_gif : bool, optional
+        If True, saves the animation to a .gif file. Default is False.
+    filename : str, optional
+        Filename (without extension) for saved .gif. Default is 'animation'.
+    title : bool, optional
+        If True, displays the temperature in the title of each frame. Default is True.
+    title_fmt : str, optional
+        Format string for temperature values (e.g., '.2f' for 2 decimals). Default is 'd' (integer).
+    plot_slice_kwargs : dict, optional
+        Additional keyword arguments passed to `plot_slice`.
+    ax_kwargs : dict, optional
+        Keyword arguments passed to `ax.set`.
+
+    Returns
+    -------
+    ani : matplotlib.animation.FuncAnimation
+        The resulting animation object.
+    """
+    if ax is None:
+        fig,ax = plt.subplots() # Generate a new figure and axis
+    else:
+        fig = ax.figure  # Get the figure from the provided axis
+
+
+    if plot_slice_kwargs is None:
+        plot_slice_kwargs = {}
+    if ax_kwargs is None:
+        ax_kwargs = {}
+
+    # Normalize the slice object
+    normalized_slice = [slice(None) if s is None else s for s in slice_obj]
+
+    # Warn if colorbar is requested
+    if plot_slice_kwargs.get('cbar', False):
+        warnings.warn("Colorbar is not supported in animation and will be ignored.", UserWarning)
+        plot_slice_kwargs['cbar'] = False
+    elif 'cbar' not in plot_slice_kwargs.keys():
+        plot_slice_kwargs['cbar'] = False
+
+    def update(temp):
+        ax.clear()
+        dataset = temp_dependence.datasets[temp]
+        plot_slice(dataset[tuple(normalized_slice)], ax=ax, **plot_slice_kwargs)
+        ax.set(**ax_kwargs)
+
+        if title:
+            try:
+                formatted_temp = f"{int(temp):{title_fmt}}"
+            except ValueError:
+                raise ValueError(f"Invalid title_fmt '{title_fmt}' for temperature value '{temp}'")
+            ax.set(title=f'$T$={formatted_temp}')
+
+    ani = animation.FuncAnimation(fig, update,
+                                  frames=temp_dependence.temperatures,
+                                  interval=interval, repeat=False)
+
+    display(HTML(ani.to_jshtml()))
+
+    if save_gif:
+        gif_file = f'{filename}.gif'
+        writer = animation.PillowWriter(fps=1000 / interval)
+        ani.save(gif_file, writer=writer)
+        with open(gif_file, 'rb') as f:
+            display(Image(f.read(), format='gif'))
+
+    return ani
+
+def animate_slice_axis(data, axis, axis_values, ax=None, interval=500, save_gif=False, filename='animation', title=True, title_fmt='.2f', plot_slice_kwargs={}, ax_kwargs={}):
+    """
+    Animate 2D slices of a 3D dataset along a given axis.
+
+    Creates a matplotlib animation by sweeping through 2D slices of a 3D 
+    dataset along the specified axis. Optionally displays the animation 
+    inline (e.g., in Jupyter) and/or saves it as a GIF.
+
+    Parameters
+    ----------
+    data : nexusformat.nexus.NXdata
+        The 3D dataset to visualize.
+    axis : int
+        The axis along which to animate (must be 0, 1, or 2).
+    axis_values : iterable
+        The values along the animation axis to use as animation frames.
+    ax : matplotlib.axes.Axes, optional
+        The axes object to plot on. If None, a new figure and axes will be created.
+    interval : int, optional
+        Delay between frames in milliseconds. Default is 500.
+    save_gif : bool, optional
+        If True, saves the animation as a .gif file. Default is False.
+    filename : str, optional
+        Filename (without extension) to use for the saved .gif. Default is 'animation'.
+    title : bool, optional
+        If True, displays the axis value as a title for each frame. Default is True.
+    title_fmt : str, optional
+        Format string for axis value in the title (e.g., '.2f' for 2 decimals). Default is '.2f'.
+    plot_slice_kwargs : dict, optional
+        Additional keyword arguments passed to `plot_slice`.
+    ax_kwargs : dict, optional
+        Keyword arguments passed to `ax.set` to update axis settings.
+
+    Returns
+    -------
+    ani : matplotlib.animation.FuncAnimation
+        The animation object.
+    """
+    if ax is None:
+        fig,ax = plt.subplots() # Generate a new figure and axis
+    else:
+        fig = ax.figure  # Get the figure from the provided axis
+
+    if axis not in [0, 1, 2]:
+        raise ValueError("axis must be either 0, 1, or 2.")
+
+    if plot_slice_kwargs.get('cbar', False):
+        warnings.warn("Colorbar is not supported in animation and will be ignored.", UserWarning)
+        plot_slice_kwargs['cbar'] = False
+    elif 'cbar' not in plot_slice_kwargs.keys():
+        plot_slice_kwargs['cbar'] = False
+
+    
+
+    def update(parameter):
+        ax.clear()
+
+        # Construct slicing object for the selected axis
+        slice_obj = [slice(None)] * 3
+        slice_obj[axis] = parameter
+
+        # Plot the 2D slice
+        plot_slice(data[tuple(slice_obj)], ax=ax, **plot_slice_kwargs)
+        ax.set(**ax_kwargs)
+
+        if title:
+            axis_label = data.axes[axis]
+            ax.set(title=f'${axis_label}$={parameter:{title_fmt}}')
+
+    ani = animation.FuncAnimation(fig, update, frames=axis_values, interval=interval, repeat=False)
+
+    display(HTML(ani.to_jshtml()))
+
+    if save_gif:
+        gif_file = f'{filename}.gif'
+        writergif = animation.PillowWriter(fps=1000/interval)
+        ani.save(gif_file, writer=writergif)
+        display(HTML(ani.to_jshtml()))
+        with open(gif_file, 'rb') as file:
+            display(Image(file.read(), format='gif'))
+
+    return ani
+
 
 class Scissors:
     """

{nxs_analysis_tools-0.1.5 → nxs_analysis_tools-0.1.7}/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):
         """