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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.1.5
+Version: 0.1.6
 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.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.1.5'
+version = '0.1.6'
 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.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.5 → 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.5'
+__version__ = '0.1.6'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.1.5 → 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.
@@ -469,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)
@@ -548,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.
 
         """
@@ -561,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
         ----------
@@ -573,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.
@@ -585,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.
@@ -657,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.5 → 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):
         """