nxs-analysis-tools 0.1.13__py3-none-any.whl

nxs_analysis_tools/datasets.py

@@ -0,0 +1,137 @@
+import os
+import pooch
+
+GOODBOY = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/cubic"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-cubic/main/data/",
+    registry={
+        "cubic_15.nxs": None,
+        "15/transform.nxs": None,
+        "cubic_25.nxs": None,
+        "25/transform.nxs": None,
+        "cubic_35.nxs": None,
+        "35/transform.nxs": None,
+        "cubic_45.nxs": None,
+        "45/transform.nxs": None,
+        "cubic_55.nxs": None,
+        "55/transform.nxs": None,
+        "cubic_65.nxs": None,
+        "65/transform.nxs": None,
+        "cubic_75.nxs": None,
+        "75/transform.nxs": None,
+        "cubic_80.nxs": None,
+        "80/transform.nxs": None,
+        "cubic_104.nxs": None,
+        "104/transform.nxs": None,
+        "cubic_128.nxs": None,
+        "128/transform.nxs": None,
+        "cubic_153.nxs": None,
+        "153/transform.nxs": None,
+        "cubic_177.nxs": None,
+        "177/transform.nxs": None,
+        "cubic_202.nxs": None,
+        "202/transform.nxs": None,
+        "cubic_226.nxs": None,
+        "226/transform.nxs": None,
+        "cubic_251.nxs": None,
+        "251/transform.nxs": None,
+        "cubic_275.nxs": None,
+        "275/transform.nxs": None,
+        "cubic_300.nxs": None,
+        "300/transform.nxs": None,
+    }
+)
+
+def fetch_cubic(temperatures=None):
+    """
+    Load the cubic dataset.
+    """
+    fnames = []
+    temperatures = [15, 25, 35, 45, 55, 65, 75, 80, 104, 128,
+                    153, 177, 202, 226, 251, 275, 300] if temperatures is None else temperatures
+    for T in temperatures:
+        fnames.append(GOODBOY.fetch(f"cubic_{T}.nxs"))
+        fnames.append(GOODBOY.fetch(f"{T}/transform.nxs"))
+    return fnames
+
+def cubic(temperatures=None):
+    fnames = fetch_cubic(temperatures)
+    dirname = os.path.dirname(fnames[0])
+    return dirname
+
+POOCH = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/hexagonal"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-hexagonal/main/data/",
+    registry={
+        "hexagonal_15.nxs": "850d666d6fb0c7bbf7f7159fed952fbd53355c3c0bfb40410874d3918a3cca49",
+        "15/transform.nxs": "45c089be295e0a5b927e963540a90b41f567edb75f283811dbc6bb4a26f2fba5",
+        "hexagonal_300.nxs": "c6a9ff704d1e42d9576d007a92a333f529e3ddf605e3f76a82ff15557b7d4a43",
+        "300/transform.nxs": "e665ba59debe8e60c90c3181e2fb1ebbce668a3d3918a89a6bf31e3563ebf32e",
+    }
+)
+
+def fetch_hexagonal(temperatures=None):
+    """
+    Load the hexagonal dataset.
+    """
+    fnames = []
+    temperatures = [15, 300] if temperatures is None else temperatures
+    for T in temperatures:
+        fnames.append(POOCH.fetch(f"hexagonal_{T}.nxs"))
+        fnames.append(POOCH.fetch(f"{T}/transform.nxs"))
+    return fnames
+
+def hexagonal(temperatures=None):
+    fnames = fetch_hexagonal(temperatures)
+    dirname = os.path.dirname(fnames[0])
+    return dirname
+
+LARGEBOI = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/orthorhombic"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-orthorhombic/main/data/",
+    registry={
+        "orthorhombic_15.nxs": None,
+        "15/transform.nxs": None,
+        "orthorhombic_100.nxs": None,
+        "100/transform.nxs": None,
+        "orthorhombic_300.nxs": None,
+        "300/transform.nxs": None,
+    }
+)
+
+def fetch_orthorhombic(temperatures=None):
+    """
+    Load the orthorhombic dataset.
+    """
+    fnames = []
+    temperatures = [15, 100, 300] if temperatures is None else temperatures
+    for T in temperatures:
+        fnames.append(LARGEBOI.fetch(f"orthorhombic_{T}.nxs"))
+        fnames.append(LARGEBOI.fetch(f"{T}/transform.nxs"))
+    return fnames
+
+def orthorhombic(temperatures=None):
+    fnames = fetch_orthorhombic(temperatures)
+    dirname = os.path.dirname(fnames[0])
+    return dirname
+
+BONES = pooch.create(
+    path=pooch.os_cache("nxs_analysis_tools/vacancies"),
+    base_url="https://raw.githubusercontent.com/stevenjgomez/dataset-vacancies/main/",
+    registry={
+        "vacancies.nxs": "39eaf8df84a0dbcacbe6ce7c6017da4da578fbf68a6218ee18ade3953c26efb5",
+        "fft.nxs": "c81178eda0ec843502935f29fcb2b0b878f7413e461612c731d37ea9e5e414a9",
+    }
+)
+
+def vacancies():
+    """
+    Load the vacancies dataset.
+    """
+    return BONES.fetch(f"vacancies.nxs")
+
+def vacanciesfft():
+    """
+    Load the vacancies fft dataset.
+    """
+    return BONES.fetch(f"fft.nxs")

nxs_analysis_tools/fitting.py

@@ -0,0 +1,301 @@
+"""
+Module for fitting of linecuts using the lmfit package.
+"""
+
+import operator
+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
+
+
+class LinecutModel:
+    """
+    A class representing a linecut model for data analysis and fitting.
+
+    Attributes
+    ----------
+    y : array-like or None
+        The dependent variable data.
+    x : array-like or None
+        The independent variable data.
+    y_eval : array-like or None
+        The evaluated y-values of the fitted model.
+    x_eval : array-like or None
+        The x-values used for evaluation.
+    y_eval_components : dict or None
+        The evaluated y-values of the model components.
+    y_fit_components : dict or None
+        The fitted y-values of the model components.
+    y_fit : array-like or None
+        The fitted y-values of the model.
+    x_fit : array-like or None
+        The x-values used for fitting.
+    y_init_fit : array-like or None
+        The initial guess of the y-values.
+    params : Parameters or None
+        The parameters of the model.
+    model_components : Model or list of Models or None
+        The model component(s) used for fitting.
+    model : Model or None
+        The composite model used for fitting.
+    modelresult : ModelResult or None
+        The result of the model fitting.
+    data : NXdata or None
+        The 1D linecut data used for analysis.
+
+    Methods
+    -------
+    __init__(self, data=None)
+        Initialize the LinecutModel.
+    set_data(self, data)
+        Set the data for analysis.
+    set_model_components(self, model_components)
+        Set the model components.
+    set_param_hint(self, *args, **kwargs)
+        Set parameter hints for the model.
+    make_params(self)
+        Create and initialize the parameters for the model.
+    guess(self)
+        Perform initial guesses for each model component.
+    print_initial_params(self)
+        Print out initial guesses for each parameter of the model.
+    plot_initial_guess(self, numpoints=None)
+        Plot the initial guess.
+    fit(self)
+        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.
+    """
+    def __init__(self, data=None):
+        """
+        Initialize the LinecutModel.
+        """
+        self.y = None
+        self.x = None
+        self.y_eval = None
+        self.x_eval = None
+        self.y_eval_components = None
+        self.y_fit_components = None
+        self.y_fit = None
+        self.x_fit = None
+        self.y_init_fit = None
+        self.params = None
+        self.model_components = None
+        self.model = None
+        self.modelresult = None
+        self.data = data if data is not None else None
+        if self.data is not None:
+            self.x = data[data.axes].nxdata
+            self.y = data[data.signal].nxdata
+
+    def set_data(self, data):
+        """
+        Set the data for analysis.
+
+        Parameters
+        ----------
+        data : NXdata
+            The 1D linecut data to be used for analysis.
+        """
+        self.data = data
+        self.x = data[data.axes].nxdata
+        self.y = data[data.signal].nxdata
+
+    def set_model_components(self, model_components):
+        """
+        Set the model components
+
+        Parameters
+        ----------
+        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
+            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]
+
+            # Combine remaining components into the composite model
+            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. These are implemented when the .make_params() method
+        is called.
+
+        Parameters
+        ----------
+        *args : positional arguments
+            Positional arguments passed to the `set_param_hint` method of the underlying model.
+
+        **kwargs : keyword arguments
+            Keyword arguments passed to the `set_param_hint` method of the underlying model.
+        """
+
+        self.model.set_param_hint(*args, **kwargs)
+
+    def make_params(self):
+        """
+        Create and initialize the parameters for the model.
+
+        Returns
+        -------
+        Parameters
+            The initialized parameters for the model.
+        """
+        # Initialize empty parameters (in function)
+        params = self.model.make_params()
+        self.params = params
+
+        return params
+
+    def guess(self):
+        """
+        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.
+        """
+        
+        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):
+        """
+        Print out initial guesses for each parameter of the model.
+        """
+        model = self.model
+        for param, hint in model.param_hints.items():
+            print(f'{param}')
+            for key, value in hint.items():
+                print(f'\t{key}: {value}')
+
+    def plot_initial_guess(self, numpoints=None):
+        """
+        Plot initial guess.
+        """
+        model = self.model
+        params = self.params
+        x = self.x
+        y = self.y
+        y_init_fit = model.eval(params=params, x=x)
+        self.y_init_fit = y_init_fit
+        plt.plot(x, y, 'o', label='data')
+        plt.plot(x, y_init_fit, '--', label='guess')
+
+        # Plot the components of the model
+        if numpoints is None:
+            numpoints = len(self.x)
+        self.x_eval = np.linspace(self.x.min(), self.x.max(), numpoints)
+        y_init_fit_components = model.eval_components(params=params, x=self.x_eval)
+        ax = plt.gca()
+        for model_component, value in y_init_fit_components.items():
+            ax.fill_between(self.x_eval, value, alpha=0.3, label=model_component)
+        plt.legend()
+        plt.show()
+
+    def fit(self):
+        """
+        Fit the model to the data.
+
+        This method fits the model to the data using the specified parameters and the x-values.
+        It updates the model result, fitted y-values, and the evaluated components.
+
+        """
+        self.modelresult = self.model.fit(self.y, self.params, x=self.x)
+        self.y_fit = self.modelresult.eval(x=self.x)
+        self.y_fit_components = self.modelresult.eval_components(x=self.x)
+
+    def plot_fit(self, numpoints=None, fit_report=True, **kwargs):
+        """
+        Plot the fitted model.
+
+        This method plots the fitted model along with the original data.
+        It evaluates the model and its components at the specified number of points (numpoints)
+        and plots the results.
+
+        Parameters
+        ----------
+        numpoints : int, optional
+            Number of points to evaluate the model and its components. If not provided,
+            it defaults to the length of the x-values.
+
+        fit_report : bool, optional
+            Whether to print the fit report. Default is True.
+
+        **kwargs : dict, optional
+            Additional keyword arguments to be passed to the `plot` method.
+
+        Returns
+        -------
+        ax : matplotlib.axes.Axes
+            The Axes object containing the plot.
+
+        """
+        if numpoints is None:
+            numpoints = len(self.x)
+        self.x_eval = np.linspace(self.x.min(), self.x.max(), numpoints)
+        self.y_eval = self.modelresult.eval(x=self.x_eval)
+        self.y_eval_components = self.modelresult.eval_components(x=self.x_eval)
+        self.modelresult.plot(numpoints=numpoints, **kwargs)
+        ax = plt.gca()
+        for model_component, value in self.y_eval_components.items():
+            ax.fill_between(self.x_eval, value, alpha=0.3, label=model_component)
+            # ax.plot(self.x_eval, value, label=model_component)
+        plt.legend()
+        plt.show()
+        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):
+        """
+        Show fit report.
+        """
+        print(self.modelresult.fit_report())

nxs_analysis_tools/lineartransformations.py

@@ -0,0 +1,51 @@
+import numpy as np
+from scipy.ndimage import affine_transform
+from matplotlib.transforms import Affine2D
+
+def shear_transformation(angle):
+    # Define shear transformation
+    t = Affine2D()
+
+    # Scale y-axis to preserve norm while shearing
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180))
+
+    # Shear along x-axis
+    t += Affine2D().skew_deg(angle, 0)
+
+    # Return to original y-axis scaling
+    t += Affine2D().scale(1, np.cos(angle * np.pi / 180)).inverted()
+
+    return t
+
+class ShearTransformer():
+    def __init__(self, angle):
+        self.shear_angle = 90 - angle
+        self.t = shear_transformation(self.shear_angle)
+        self.scale = np.cos(self.shear_angle * np.pi / 180)
+
+    def apply(self, image):
+        # Perform shear operation
+        image_skewed = affine_transform(image, self.t.inverted().get_matrix()[:2, :2], 
+                                        offset=[image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180), 0], 
+                                        order=0
+                                        )
+        # Scale data based on skew angle
+        image_scaled = affine_transform(image_skewed, Affine2D().scale(self.scale, 1).get_matrix()[:2, :2],
+                                        offset=[(1 - self.scale) * image.shape[0] / 2, 0],
+                                        order=0
+                                        )
+        return image_scaled
+
+    def invert(self, image):
+
+        # Undo scaling
+        image_unscaled = affine_transform(image, Affine2D().scale(self.scale, 1).inverted().get_matrix()[:2, :2],
+                                          offset=[-(1 - self.scale) * image.shape[0] / 2 / self.scale, 0],
+                                          order=0
+                                          )
+        # Undo shear operation
+        image_unskewed = affine_transform(image_unscaled, self.t.get_matrix()[:2, :2],
+                                          offset=[(-image.shape[0] / 2 * np.sin(self.shear_angle * np.pi / 180)), 0],
+                                          order=0
+                                          )
+        return image_unskewed