nxs-analysis-tools 0.1.8__tar.gz → 0.1.10__tar.gz

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.1.8
+Version: 0.1.10
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License-Expression: MIT
@@ -46,6 +46,7 @@ Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx-copybutton>=0.5.0; extra == "dev"
 Requires-Dist: sphinxext-opengraph>=0.6.3; extra == "dev"
 Requires-Dist: twine>=4.0.1; extra == "dev"
+Requires-Dist: pooch>=1.8.2; extra == "dev"
 Dynamic: license-file
 
 # nxs-analysis-tools
@@ -76,4 +77,14 @@ git clone https://github.com/stevenjgomez/nxs-analysis-tools.git
 
 ## License
 
-This project is licensed under the MIT License.
+This project is licensed under the MIT License. If you find the nxs-analysis-tools package useful in your scientific publications, please cite the relevant DOI.
+
+To cite the most recent version, use:
+
+[![DOI](https://zenodo.org/badge/644189683.svg)](https://doi.org/10.5281/zenodo.15186359)
+
+To cite all versions, use:
+
+```
+10.5281/zenodo.15186359
+```

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/README.md

@@ -26,4 +26,14 @@ git clone https://github.com/stevenjgomez/nxs-analysis-tools.git
 
 ## License
 
-This project is licensed under the MIT License.
+This project is licensed under the MIT License. If you find the nxs-analysis-tools package useful in your scientific publications, please cite the relevant DOI.
+
+To cite the most recent version, use:
+
+[![DOI](https://zenodo.org/badge/644189683.svg)](https://doi.org/10.5281/zenodo.15186359)
+
+To cite all versions, use:
+
+```
+10.5281/zenodo.15186359
+```

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.1.8'
+version = '0.1.10'
 description = 'Reduce and transform nexus format (.nxs) scattering data.'
 readme = 'README.md'
 requires-python = '>=3.7'
@@ -61,6 +61,7 @@ dev = [
     'sphinx-copybutton >= 0.5.0',
     'sphinxext-opengraph >= 0.6.3',
     'twine >= 4.0.1',
+    'pooch >= 1.8.2',
 ]
 
 [project.urls]
@@ -71,7 +72,7 @@ dev = [
 'DOI' = 'https://doi.org/10.5281/zenodo.15186359'
 
 [tool.bumpver]
-current_version = "0.1.8"
+current_version = "0.1.10"
 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.8 → nxs_analysis_tools-0.1.10}/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.8'
+__version__ = '0.1.10'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/src/nxs_analysis_tools/chess.py

@@ -1,7 +1,7 @@
 """
 This module provides classes and functions for analyzing scattering datasets collected at CHESS
-(ID4B) with temperature dependence. It includes functions for loading data, cutting data, and
-plotting linecuts.
+(ID4B) with temperature dependence. It includes functions for loading temperature series and 
+performing operations on all datasets in the series at once (e.g., cutting, fitting). 
 """
 import os
 import re
@@ -59,10 +59,11 @@ class TempDependence:
         Initialize Scissors and LinecutModel objects for each temperature.
     set_data(temperature, data):
         Set the dataset for a specific temperature.
-    load_transforms(temperatures_list=None, print_tree=True):
+    load_transforms(temperatures_list=None, exclude_temperatures=None, print_tree=True):
         Load transform datasets (from nxrefine) based on temperature.
-    load_datasets(file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
-        Load datasets (CHESS format) from the specified folder.
+    load_datasets(file_ending='hkli.nxs', temperatures_list=None, exclude_temperatures=None, 
+                  print_tree=True):
+        Load datasets (legacy CHESS format) from the specified folder.
     get_sample_directory():
         Get the folder path where the datasets are located.
     clear_datasets():
@@ -99,11 +100,12 @@ class TempDependence:
         Fit the line cut models for each temperature.
     plot_fit(mdheadings=False, **kwargs):
         Plot the fit results for each temperature.
-    overlay_fits(numpoints=None, vertical_offset=0, cmap='viridis', ax=ax):
+    overlay_fits(numpoints=None, vertical_offset=0, cmap='viridis', ax=ax, 
+                 data_kwargs=None, fit_kwargs=None):
         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_order_parameter(ax, param_name='peakheight', **kwargs):
         Plot the temperature dependence of the peakheight parameter.
     print_fit_report():
         Print the fit report for each temperature.
@@ -188,6 +190,8 @@ class TempDependence:
         """
         for temperature in self.temperatures:
             self.scissors[temperature] = Scissors()
+            if temperature in self.datasets.keys():
+                self.scissors[temperature].set_data(self.datasets[temperature])
             self.linecutmodels[temperature] = LinecutModel()
 
     def set_data(self, temperature, data):
@@ -203,7 +207,7 @@ class TempDependence:
         """
         self.datasets[temperature] = data
 
-    def load_transforms(self, temperatures_list=None, print_tree=True, use_nxlink=False):
+    def load_transforms(self, temperatures_list=None, exclude_temperatures=None, print_tree=True, use_nxlink=False):
         """
         Load transform datasets (from nxrefine) based on temperature.
 
@@ -211,6 +215,9 @@ class TempDependence:
         ----------
         temperatures_list : list of int or None, optional
             List of temperatures to load. If None, all available temperatures are loaded.
+
+        exclude_temperatures : int, str, optional
+            Temperatures to skip. Applied after filtering with `temperatures_list`, if provided.
         
         print_tree : bool, optional
             Whether to print the data tree upon loading. Default True.
@@ -223,6 +230,10 @@ class TempDependence:
         # Convert all temperatures to strings
         if temperatures_list:
             temperatures_list = [str(t) for t in temperatures_list]
+        if exclude_temperatures:
+            if isinstance(exclude_temperatures, str):
+                exclude_temperatures = [exclude_temperatures]
+            exclude_temperatures = [str(t) for t in list(exclude_temperatures)]
 
         # Clear existing temperatures before loading files
         self.temperatures = []
@@ -237,7 +248,15 @@ class TempDependence:
                 # Identify temperature
                 temperature = match.group(1)
                 # print(f'Temperature = {temperature}')
-                if (temperatures_list is None) or (temperature in temperatures_list):
+                if temperatures_list is not None:
+                    incl_temp = temperature in temperatures_list
+                else:
+                    incl_temp = True
+                if exclude_temperatures is not None:
+                    not_excl_temp = temperature not in exclude_temperatures
+                else:
+                    not_excl_temp = True
+                if incl_temp and not_excl_temp:
                     # Prepare file to be loaded
                     self.temperatures.append(temperature)
                     items_to_load.append(item)
@@ -269,40 +288,38 @@ class TempDependence:
                       f" Error: {e}")
                 raise  # Re-raise the exception
 
-            # Initialize scissors object
-            self.scissors[self.temperatures[i]] = Scissors()
-            self.scissors[self.temperatures[i]].set_data(self.datasets[self.temperatures[i]])
+        self.initialize()
 
-            # Initialize linecutmodel object
-            self.linecutmodels[self.temperatures[i]] = LinecutModel()
-
-    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
+    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None, exclude_temperatures=None, print_tree=True):
         """
         Load datasets (CHESS format) from the specified folder.
 
         Parameters
         ----------
         file_ending : str, optional
-            The file extension of the datasets to be loaded. The default is 'hkli.nxs'.
-        temperatures_list : list of int or None, optional
-            The list of specific temperatures to load. If None, all available temperatures are
-            loaded. The default is None.
+            File extension of datasets to load. Default is 'hkli.nxs'.
+        temperatures_list : list of int or str, optional
+            Specific temperatures to load. If None, all temperatures are loaded.
+        exclude_temperatures : list of int or str, optional
+            Temperatures to skip. Applied after filtering with `temperatures_list`, if provided.
         print_tree : bool, optional
-            Whether to print the data tree upon loading. Default True.
+            If True, prints the NeXus tree structure for each file. Default is True.
         """
-        temperature_folders = []  # Empty list to store temperature folder names
-        for item in os.listdir(self.sample_directory):
-            try:
-                temperature_folders.append(int(item))  # If folder name can be int, add it
-            except ValueError:
-                pass  # Otherwise don't add it
-        temperature_folders.sort()  # Sort from low to high T
-        temperature_folders = [str(i) for i in temperature_folders]  # Convert to strings
-
-        self.temperatures = temperature_folders
 
         if temperatures_list is not None:
             self.temperatures = [str(t) for t in temperatures_list]
+        else:
+            self.temperatures = []  # Empty list to store temperature folder names
+            for item in os.listdir(self.sample_directory):
+                try:
+                    self.temperatures.append(int(item))  # If folder name can be int, add it
+                except ValueError:
+                    pass  # Otherwise don't add it
+            self.temperatures.sort()  # Sort from low to high T
+            self.temperatures = [str(i) for i in self.temperatures]  # Convert to strings
+            
+        if exclude_temperatures is not None:
+            [self.temperatures.remove(str(t)) for t in exclude_temperatures]
 
         # Load .nxs files
         for T in self.temperatures:
@@ -313,12 +330,7 @@ class TempDependence:
                     # Load dataset at each temperature
                     self.datasets[T] = load_data(filepath, print_tree)
 
-                    # Initialize scissors object at each temperature
-                    self.scissors[T] = Scissors()
-                    self.scissors[T].set_data(self.datasets[T])
-
-                    # Initialize linecutmodel object at each temperature
-                    self.linecutmodels[T] = LinecutModel()
+        self.initialize()
 
     def get_sample_directory(self):
         """
@@ -437,11 +449,16 @@ class TempDependence:
         # Get the Viridis colormap
         cmap = mpl.colormaps.get_cmap('viridis')
 
+        # Reverse zorder
+        zorder = 0
+
         for i, linecut in enumerate(self.linecuts.values()):
+            
             x_data = linecut[linecut.axes].nxdata
             y_data = linecut[linecut.signal].nxdata + i * vertical_offset
-            ax.plot(x_data, y_data, color=cmap(i / len(self.linecuts)), label=self.temperatures[i],
-                    **kwargs)
+            ax.plot(x_data, y_data, color=cmap(i / len(self.linecuts)), label=self.temperatures[i], 
+                    zorder=zorder, **kwargs)
+            zorder -= 1
 
         ax.set(xlabel=self.xlabel,
                ylabel=self.linecuts[self.temperatures[0]].signal)
@@ -704,7 +721,8 @@ class TempDependence:
                                   title=f"{T} K",
                                   **kwargs)
 
-    def overlay_fits(self, numpoints=None, vertical_offset=0, cmap='viridis', ax=None):
+    def overlay_fits(self, numpoints=None, vertical_offset=0, cmap='viridis', ax=None,
+                     data_kwargs=None, fit_kwargs=None):
         """
         Plot raw data and fitted models for each temperature with optional vertical offsets.
 
@@ -719,6 +737,11 @@ class TempDependence:
             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.
+        data_kwargs : dict
+            Keyword arguments to be passed to the data plot function.
+        fit_kwargs : dict
+            Keyword arguments to be passed to the fit plot function.
+
 
         The function:
         - Uses a colormap to assign unique colors to each temperature.
@@ -731,19 +754,24 @@ class TempDependence:
         # Create a figure and axes if an axis is not already provided
         _, ax = plt.subplots() if ax is None else (None, ax)
 
+        if data_kwargs is None:
+            data_kwargs = {}
+        if fit_kwargs is None:
+            fit_kwargs = {}
+
         # 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])
+            ax.plot(lm.x, lm.y + vertical_offset * i, '.', c=colors[i], **data_kwargs)
 
             # 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])
+            ax.plot(x_eval, y_eval + vertical_offset * i, '-', c=colors[i], label=self.temperatures[i], **fit_kwargs)
 
         # Reverse legend entries to match top-to-bottom stacking
         handles, labels = ax.get_legend_handles_labels()
@@ -767,18 +795,19 @@ class TempDependence:
             linecutmodel.params['peakamplitude'].set(min=0)
             linecutmodel.fit()
 
-    def plot_order_parameter(self, ax=None, **kwargs):
+    def plot_order_parameter(self, param_name='peakheight', ax=None, **kwargs):
         """
         Plot the temperature dependence of the peak height (order parameter).
 
-        This method extracts the peak height from each temperature-dependent
-        line cut fit stored in `linecutmodels` and plots it as a function
-        of temperature using matplotlib.
+        This method extracts the values of a chosen parameter from each temperature-dependent
+        line cut fit stored in `linecutmodels` and plots it as a function of temperature.
 
         Parameters
         ----------
         ax : :class:`matplotlib.axes.Axes`, optional
             Axis object to plot on. If None, a new figure and axis are created.
+        param_name : str, optional
+            The name of the lmfit parameter to extract. Default is 'peakheight'.
         **kwargs
             Keyword arguments to be passed to the plot function.
 
@@ -810,7 +839,7 @@ class TempDependence:
             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)
+            peakheights.append(self.linecutmodels[T].modelresult.params[param_name].value)
 
         # Plot the peakheights vs. temperature
         if ax is None:
@@ -818,7 +847,7 @@ class TempDependence:
         else:
             fig = ax.figure
         ax.plot(temperatures, peakheights, **kwargs)
-        ax.set(xlabel='$T$ (K)', ylabel='peakheight')
+        ax.set(xlabel='$T$ (K)', ylabel=param_name)
         return fig, ax
 
     def print_fit_report(self):

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/src/nxs_analysis_tools/datareduction.py

@@ -1,5 +1,6 @@
 """
-Reduces scattering data into 2D and 1D datasets.
+Tools for reducing data into 2D and 1D, and visualization functions for plotting and animating 
+data.
 """
 import os
 import io
@@ -397,7 +398,8 @@ def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None,
 
     # If three-dimensional, demand sum_axis to reduce to two dimensions.
     if data.ndim == 3:
-        assert sum_axis is not None, "sum_axis must be specified when data.ndim == 3."
+        if sum_axis is None:
+            raise ValueError("sum_axis must be specified when data.ndim == 3.")
 
         if is_array:
             data = data.sum(axis=sum_axis)
@@ -608,8 +610,9 @@ 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):
+def animate_slice_temp(temp_dependence, slice_obj, ax=None, reverse_temps=False, 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.
 
@@ -625,6 +628,8 @@ def animate_slice_temp(temp_dependence, slice_obj, ax=None, interval=500, save_g
         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.
+    reverse_temps : bool, optional
+        If True, animates datasets with increasing temperature. Default is False.
     interval : int, optional
         Delay between frames in milliseconds. Default is 500.
     save_gif : bool, optional
@@ -679,8 +684,17 @@ def animate_slice_temp(temp_dependence, slice_obj, ax=None, interval=500, save_g
                 raise ValueError(f"Invalid title_fmt '{title_fmt}' for temperature value '{temp}'")
             ax.set(title=f'$T$={formatted_temp}')
 
+    # Animate frames upon warming
+    if reverse_temps:
+        frames = temp_dependence.temperatures.copy()
+    # Animate frames upon cooling (default)
+    else:
+        frames = temp_dependence.temperatures.copy()
+        frames.reverse()
+        
+
     ani = animation.FuncAnimation(fig, update,
-                                  frames=temp_dependence.temperatures,
+                                  frames=frames,
                                   interval=interval, repeat=False)
 
     display(HTML(ani.to_jshtml()))
@@ -761,7 +775,7 @@ def animate_slice_axis(data, axis, axis_values, ax=None, interval=500, save_gif=
 
         if title:
             axis_label = data.axes[axis]
-            ax.set(title=f'${axis_label}$={parameter:{title_fmt}}')
+            ax.set(title=f'{axis_label}={parameter:{title_fmt}}')
 
     ani = animation.FuncAnimation(fig, update, frames=axis_values, interval=interval, repeat=False)
 
@@ -1299,7 +1313,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
                                                   order=0,
                                                   )
         # Scale data based on ratio of array dimensions
-        scale2 = counts.shape[0] / counts.shape[1]
+        scale2 = 1 # counts.shape[0] / counts.shape[1]
         counts_scaled2 = ndimage.affine_transform(counts_scaled1,
                                                   Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
                                                   offset=[(1 - scale2) * counts.shape[0] / 2, 0],
@@ -1402,7 +1416,7 @@ def rotate_data_2D(data, lattice_angle, rotation_angle):
                                               order=0,
                                               )
     # Scale data based on ratio of array dimensions
-    scale2 = counts.shape[0] / counts.shape[1]
+    scale2 = 1 # counts.shape[0] / counts.shape[1]
     counts_scaled2 = ndimage.affine_transform(counts_scaled1,
                                               Affine2D().scale(scale2, 1).get_matrix()[:2, :2],
                                               offset=[(1 - scale2) * counts.shape[0] / 2, 0],

nxs_analysis_tools-0.1.10/src/nxs_analysis_tools/datasets.py

@@ -0,0 +1,108 @@
+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
+
+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 dataset.
+    """
+    return BONES.fetch(f"fft.nxs")

{nxs_analysis_tools-0.1.8 → nxs_analysis_tools-0.1.10}/src/nxs_analysis_tools/pairdistribution.py

@@ -349,12 +349,11 @@ class Symmetrizer2D:
         - Subplot 3: The wedge slice used for reconstruction of the full symmetrized dataset.
         - Subplot 4: The symmetrized dataset.
 
-        Example usage:
-        ```
-        s = Symmetrizer2D()
-        s.set_parameters(theta_min, theta_max, skew_angle, mirror)
-        s.test(data)
-        ```
+        Example
+        -------
+        >>> s = Symmetrizer2D()
+        >>> s.set_parameters(theta_min, theta_max, skew_angle, mirror)
+        >>> s.test(data)
         """
         s = self
         symm_test = s.symmetrize_2d(data)
@@ -400,7 +399,8 @@ class Symmetrizer3D:
             The input 3D dataset to be symmetrized.
         """
 
-        assert data is not None, "Symmetrizer3D requires a 3D NXdata object for initialization."
+        if data is None:
+            raise ValueError("Symmetrizer3D requires a 3D NXdata object for initialization.")
 
         self.a, self.b, self.c, self.al, self.be, self.ga = [None] * 6
         self.a_star, self.b_star, self.c_star, self.al_star, self.be_star, self.ga_star = [None] * 6

nxs_analysis_tools-0.1.10/src/nxs_analysis_tools.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+src/_meta/__init__.py
+src/nxs_analysis_tools/__init__.py
+src/nxs_analysis_tools/chess.py
+src/nxs_analysis_tools/datareduction.py
+src/nxs_analysis_tools/datasets.py
+src/nxs_analysis_tools/fitting.py
+src/nxs_analysis_tools/pairdistribution.py
+tests/test_loading.py
+tests/test_plot_slice.py

nxs_analysis_tools-0.1.10/tests/test_loading.py

@@ -0,0 +1,46 @@
+import pytest
+from nexusformat.nexus import NXdata, NXfield, NXentry, NXroot, NXlink
+from nexusformat.nexus import nxsave
+import numpy as np
+
+from nxs_analysis_tools.datareduction import load_transform
+from nxs_analysis_tools.chess import TempDependence
+
+# @pytest.fixture
+# def nxrefine_nxs_file(tmp_path):
+#     # Load original data
+#     x = NXfield(np.linspace(0, 1, 10))
+#     y = NXfield(np.linspace(0, 1, 10))
+#     z = NXfield(np.linspace(0, 1, 10))
+#     v = NXfield(np.random.rand(10, 10))
+#     data = NXdata(v, (x, y, z))
+#     raw_data = data.nxsignal.nxdata
+
+#     # Save intermediate transformed data
+#     out_data = NXdata(NXfield(raw_data.transpose(2, 1, 0), name='v'))
+#     # Create subfolder '15' under the temp directory
+#     transform_dir = tmp_path / '15'
+#     transform_dir.mkdir()
+#     transform_path = transform_dir / 'transform.nxs'
+#     nxsave(str(transform_path), out_data)
+
+#     # Construct final NXroot structure
+#     main_file = NXroot()
+#     main_file['entry'] = NXentry()
+#     newH = NXfield(data.nxaxes[0].nxdata, name='Qh')
+#     newK = NXfield(data.nxaxes[1].nxdata, name='Qk')
+#     newL = NXfield(data.nxaxes[2].nxdata, name='Ql')
+    
+#     main_file['entry']['transform'] = NXdata(
+#         NXlink(name='data', target='/entry/data/v', file=transform_path.name),
+#         [newL, newK, newH]
+#     )
+#     main_file.entry.transform.attrs['angles'] = [90., 90., 90.]
+#     main_file.entry.transform.attrs['signal'] = 'data'
+#     main_file.entry.transform['title'] = '15.000K Transform'
+
+#     final_file_path = tmp_path / 'CsV3Sb5_15.nxs'
+#     nxsave(str(final_file_path), main_file)
+
+#     # Return path for test usage
+#     return final_file_path