nxs-analysis-tools 0.0.45__tar.gz → 0.0.46__tar.gz

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Steven J. Gomez Alvarado
+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

{nxs_analysis_tools-0.0.45/src/nxs_analysis_tools.egg-info → nxs_analysis_tools-0.0.46}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.0.45
+Version: 0.0.46
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License
         
-        Copyright (c) 2023 Steven J. Gomez Alvarado
+        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

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.0.45'
+version = '0.0.46'
 description = 'Reduce and transform nexus format (.nxs) scattering data.'
 readme = 'README.md'
 requires-python = '>=3.7'

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/src/_meta/__init__.py

@@ -4,7 +4,7 @@
 __project__ = 'nxs-analysis-tools'
 __author__ = 'Steven J. Gomez Alvarado'
 __email__ = 'stevenjgomez@ucsb.edu'
-__copyright__ = f"2023, {__author__}"
+__copyright__ = f"2023-2025, {__author__}"
 __license__ = 'MIT'
-__version__ = '0.0.45'
+__version__ = '0.0.46'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/src/nxs_analysis_tools/chess.py

@@ -58,9 +58,9 @@ 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):
+    load_transforms(temperatures_list=None, print_tree=True):
         Load transform datasets (from nxrefine) based on temperature.
-    load_datasets(file_ending='hkli.nxs', temperatures_list=None):
+    load_datasets(file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
         Load datasets (CHESS format) from the specified folder.
     get_sample_directory():
         Get the folder path where the datasets are located.
@@ -98,6 +98,8 @@ 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):
+        Plot the temperature dependence of the peakheight parameter.
     print_fit_report():
         Print the fit report for each temperature.
     """
@@ -186,7 +188,7 @@ class TempDependence:
         """
         self.datasets[temperature] = data
 
-    def load_transforms(self, temperatures_list=None):
+    def load_transforms(self, temperatures_list=None, print_tree=True):
         """
         Load transform datasets (from nxrefine) based on temperature.
 
@@ -194,6 +196,8 @@ 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.
         """
         # Convert all temperatures to strings
         if temperatures_list:
@@ -231,7 +235,7 @@ class TempDependence:
 
             # Save dataset
             try:
-                self.datasets[self.temperatures[i]] = load_transform(path)
+                self.datasets[self.temperatures[i]] = load_transform(path, print_tree)
             except Exception as e:
                 # Report temperature that was unable to load, then raise exception.
                 temp_failed = self.temperatures[i]
@@ -245,7 +249,7 @@ class TempDependence:
             # Initialize linecutmodel object
             self.linecutmodels[self.temperatures[i]] = LinecutModel()
 
-    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None):
+    def load_datasets(self, file_ending='hkli.nxs', temperatures_list=None, print_tree=True):
         """
         Load datasets (CHESS format) from the specified folder.
 
@@ -256,6 +260,8 @@ class TempDependence:
         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.
+        print_tree : bool, optional
+            Whether to print the data tree upon loading. Default True.
         """
         temperature_folders = []  # Empty list to store temperature folder names
         for item in os.listdir(self.sample_directory):
@@ -278,7 +284,7 @@ class TempDependence:
                     filepath = os.path.join(self.sample_directory, T, file)
 
                     # Load dataset at each temperature
-                    self.datasets[T] = load_data(filepath)
+                    self.datasets[T] = load_data(filepath, print_tree)
 
                     # Initialize scissors object at each temperature
                     self.scissors[T] = Scissors()
@@ -370,15 +376,13 @@ class TempDependence:
             A dictionary of linecuts obtained from the cutting operation.
         """
 
-        center = center if center is not None else self.scissors[self.temperatures[0]].center
-        window = window if window is not None else self.scissors[self.temperatures[0]].window
-        axis = axis if axis is not None else self.scissors[self.temperatures[0]].axis
-
         for T in self.temperatures:
             if verbose:
                 print("-------------------------------")
                 print("Cutting T = " + T + " K data...")
-            self.scissors[T].cut_data(center, window, axis, verbose)
+            self.scissors[T].set_center(center)
+            self.scissors[T].set_window(window)
+            self.scissors[T].cut_data(axis=axis, verbose=verbose)
             self.linecuts[T] = self.scissors[T].linecut
             self.linecutmodels[T].set_data(self.linecuts[T])
 
@@ -466,7 +470,7 @@ class TempDependence:
             _, ax = plt.subplots()
         p = ax.pcolormesh(X, Y, v_2d, **kwargs)
         plt.colorbar(p, label='counts')
-        ax.set(xlabel=cut.axes, ylabel=r'$T$ (K)')
+        ax.set(xlabel=self.xlabel, ylabel=r'$T$ (K)')
 
         return p
 
@@ -641,6 +645,44 @@ class TempDependence:
                                   title=f"{T} K",
                                   **kwargs)
 
+    def plot_order_parameter(self):
+        """
+        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.
+
+        Returns
+        -------
+        Figure
+            Matplotlib Figure object containing the peak height vs. temperature plot.
+        Axes
+            Matplotlib Axes object associated with the figure.
+
+        Notes
+        -----
+        - Temperature values are converted to integers for plotting.
+        - Peak heights are extracted from the 'peakheight' parameter in the model results.
+        - The plot uses standard axes labels with temperature in Kelvin.
+        """
+
+        # Create an array of temperature values
+        temperatures = [int(T) for T in self.temperatures]
+
+        # Create an empty list for the peak heights
+        peakheights = []
+
+        # Extract the peakheight at every temperature
+        for T in self.temperatures:
+            peakheights.append(self.linecutmodels[T].modelresult.params['peakheight'].value)
+
+        # Plot the peakheights vs. temperature
+        fig, ax = plt.subplots()
+        ax.plot(temperatures, peakheights)
+        ax.set(xlabel='$T$ (K)', ylabel='peakheight')
+        return fig, ax
+
     def print_fit_report(self):
         """
         Plot the fit results.

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/src/nxs_analysis_tools/datareduction.py

@@ -19,7 +19,7 @@ __all__ = ['load_data', 'load_transform', 'plot_slice', 'Scissors',
            'array_to_nxdata', 'Padder']
 
 
-def load_data(path):
+def load_data(path, print_tree=True):
     """
     Load data from a NeXus file at a specified path. It is assumed that the data follows the CHESS
     file structure (i.e., root/entry/data/counts, etc.).
@@ -29,6 +29,9 @@ def load_data(path):
     path : str
         The path to the NeXus data file.
 
+    print_tree : bool, optional
+        Whether to print the data tree upon loading. Default True.
+
     Returns
     -------
     data : nxdata object
@@ -38,31 +41,42 @@ def load_data(path):
 
     g = nxload(path)
     try:
-        print(g.entry.data.tree)
+        print(g.entry.data.tree) if print_tree else None
     except NeXusError:
         pass
 
     return g.entry.data
 
 
-def load_transform(path):
+def load_transform(path, print_tree=True):
     """
     Load data obtained from nxrefine output from a specified path.
 
     Parameters
     ----------
-    path : str The path to the transform data file.
+    path : str
+        The path to the transform data file.
+
+    print_tree : bool, optional
+        Whether to print the data tree upon loading. Default True.
 
     Returns
     -------
-    data : nxdata object The loaded data stored in a nxdata object.
+    data : nxdata object
+        The loaded data stored in a nxdata object.
     """
+
     g = nxload(path)
-    return NXdata(NXfield(g.entry.transform.data.nxdata.transpose(2, 1, 0), name='counts'),
+
+    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))
 
+    print(data.tree) if print_tree else None
+
+    return data
+
 
-def array_to_nxdata(array, data_template, signal_name='counts'):
+def array_to_nxdata(array, data_template, signal_name=None):
     """
     Create an NXdata object from an input array and an NXdata template,
     with an optional signal name.
@@ -78,7 +92,7 @@ def array_to_nxdata(array, data_template, signal_name='counts'):
 
     signal_name : str, optional
         The name of the signal within the NXdata object. If not provided,
-        the default signal name 'counts' is used.
+        the signal name is inherited from the data_template.
 
     Returns
     -------
@@ -87,6 +101,8 @@ def array_to_nxdata(array, data_template, signal_name='counts'):
         based on the template.
     """
     d = data_template
+    if signal_name is None:
+        signal_name = d.signal
     return NXdata(NXfield(array, name=signal_name),
                   tuple(d[d.axes[i]] for i in range(len(d.axes))))
 

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46}/src/nxs_analysis_tools/pairdistribution.py

@@ -458,20 +458,35 @@ class Symmetrizer3D:
         self.a_star, self.b_star, self.c_star, \
             self.al_star, self.be_star, self.ga_star = self.reciprocal_lattice_params
 
-    def symmetrize(self):
+    def symmetrize(self, positive_values=True):
         """
-        Perform the symmetrization of the 3D dataset by sequentially applying
-         2D symmetrization on the three principal planes.
+        Symmetrize the 3D dataset by sequentially applying 2D symmetrization
+        on the three principal planes.
 
-        This method symmetrizes the dataset on the three principal planes
-         (q1-q2, q1-q3, q2-q3) and handles any negative values that might result
-          from the symmetrization process.
+        This method performs symmetrization along the (q1-q2), (q1-q3),
+        and (q2-q3) planes, ensuring that the dataset maintains expected
+        symmetry properties. Optionally, negative values resulting from the
+        symmetrization process can be set to zero.
+
+        Parameters
+        ----------
+        positive_values : bool, optional
+            If True, sets negative symmetrized values to zero (default is True).
 
         Returns
         -------
-        symmetrized : NXdata
-            The symmetrized 3D dataset.
+        NXdata
+            The symmetrized 3D dataset stored in the `symmetrized` attribute.
+
+        Notes
+        -----
+        - Symmetrization is performed sequentially across three principal
+          planes using corresponding 2D symmetrization methods.
+        - The process prints progress updates and timing information.
+        - If `theta_max` is not set for a particular plane symmetrizer,
+          that plane is skipped.
         """
+
         starttime = time.time()
         data = self.data
         q1, q2, q3 = self.q1, self.q2, self.q3
@@ -480,7 +495,8 @@ class Symmetrizer3D:
         if self.plane1symmetrizer.theta_max is not None:
             print('Symmetrizing ' + self.plane1 + ' planes...')
             for k, value in enumerate(q3):
-                print(f'Symmetrizing {q3.nxname}={value:.02f}...', end='\r')
+                print(f'Symmetrizing {q3.nxname}={value:.02f}.'
+                      f'..', end='\r')
                 data_symmetrized = self.plane1symmetrizer.symmetrize_2d(data[:, :, k])
                 out_array[:, :, k] = data_symmetrized[data.signal].nxdata
             print('\nSymmetrized ' + self.plane1 + ' planes.')
@@ -505,7 +521,8 @@ class Symmetrizer3D:
                 out_array[i, :, :] = data_symmetrized[data.signal].nxdata
             print('\nSymmetrized ' + self.plane3 + ' planes.')
 
-        out_array[out_array < 0] = 0
+        if positive_values:
+            out_array[out_array < 0] = 0
 
         stoptime = time.time()
         print(f"\nSymmetrization finished in {((stoptime - starttime) / 60):.02f} minutes.")
@@ -1032,15 +1049,28 @@ class Interpolator:
         """
         self.kernel = kernel
 
-    def interpolate(self):
+    def interpolate(self, verbose=True, positive_values=True):
         """
         Perform interpolation on the dataset using the specified kernel.
 
-        The interpolation is done by convolving the data with the kernel
-         using the `convolve_fft` function. Updates the `interpolated`
-          attribute with the result.
+        This method convolves the dataset with a kernel using `convolve_fft`
+        to perform interpolation. The resulting interpolated data is stored
+        in the `interpolated` attribute.
+
+        Parameters
+        ----------
+        verbose : bool, optional
+            If True, prints progress messages and timing information
+            (default is True).
+        positive_values : bool, optional
+            If True, sets negative interpolated values to zero
+            (default is True).
 
-        Prints the time taken for the interpolation process.
+        Notes
+        -----
+        - The convolution operation is performed in Fourier space.
+        - If a previous interpolation time is recorded, it is displayed
+          before starting a new interpolation.
 
         Returns
         -------
@@ -1048,21 +1078,22 @@ class Interpolator:
         """
         start = time.time()
 
-        if self.interp_time:
+        if self.interp_time and verbose:
             print(f"Last interpolation took {self.interp_time / 60:.2f} minutes.")
 
-        print("Running interpolation...")
+        print("Running interpolation...") if verbose else None
         result = np.real(
             convolve_fft(self.data[self.data.signal].nxdata,
                          self.kernel, allow_huge=True, return_fft=False))
-        print("Interpolation finished.")
+        print("Interpolation finished.") if verbose else None
 
         end = time.time()
         interp_time = end - start
 
-        print(f'Interpolation took {interp_time / 60:.2f} minutes.')
+        print(f'Interpolation took {interp_time / 60:.2f} minutes.') if verbose else None
 
-        result[result < 0] = 0
+        if positive_values:
+            result[result < 0] = 0
         self.interpolated = array_to_nxdata(result, self.data)
 
     def set_tukey_window(self, tukey_alphas=(1.0, 1.0, 1.0)):
@@ -1479,21 +1510,34 @@ class DeltaPDF:
         self.interpolator.set_kernel(kernel)
         self.kernel = kernel
 
-    def interpolate(self):
+    def interpolate(self, verbose=True, positive_values=True):
         """
         Perform interpolation on the dataset using the specified kernel.
 
-        The interpolation is done by convolving the data with the kernel using
-         the `convolve_fft` function. Updates the `interpolated` attribute with
-          the result.
+        This method convolves the dataset with a kernel using `convolve_fft`
+        to perform interpolation. The resulting interpolated data is stored
+        in the `interpolated` attribute.
+
+        Parameters
+        ----------
+        verbose : bool, optional
+            If True, prints progress messages and timing information
+            (default is True).
+        positive_values : bool, optional
+            If True, sets negative interpolated values to zero
+            (default is True).
 
-        Prints the time taken for the interpolation process.
+        Notes
+        -----
+        - The convolution operation is performed in Fourier space.
+        - If a previous interpolation time is recorded, it is displayed
+          before starting a new interpolation.
 
         Returns
         -------
         None
         """
-        self.interpolator.interpolate()
+        self.interpolator.interpolate(verbose, positive_values)
         self.interpolated = self.interpolator.interpolated
 
     def set_tukey_window(self, tukey_alphas=(1.0, 1.0, 1.0)):
@@ -1578,14 +1622,16 @@ class DeltaPDF:
         """
         Perform a 3D Fourier Transform on the padded data.
 
-        This function applies an inverse Fourier Transform to the padded data
-        using the `pyfftw` library to optimize performance. The result is a
-        transformed array with spatial frequency components calculated along
-        each axis.
+        This method applies an inverse Fourier Transform to the padded data
+        using `pyfftw` for optimized performance. The result is stored in
+        the `fft` attribute as an NXdata object containing the transformed
+        spatial frequency components.
 
         Parameters
         ----------
-        None
+        is_2d : bool, optional
+           If True, performs the FFT only along the first two axes,
+           skipping the out-of-plane direction (default is False).
 
         Returns
         -------
@@ -1593,13 +1639,12 @@ class DeltaPDF:
 
         Notes
         -----
-        - The FFT is performed in two stages: first along the last dimension of
-        the input array and then along the first two dimensions.
-        - The function uses `pyfftw` for efficient computation of the Fourier
-        Transform.
-        - The output frequency components are computed based on the step sizes
-        of the original data axes.
-
+        - Calls `fourier_transform_nxdata` to perform the transformation.
+        - The FFT is computed in two stages: first along the last dimension,
+         then along the first two dimensions.
+        - The output includes frequency components computed from the step
+         sizes of the original data axes.
 
         """
+
         self.fft = fourier_transform_nxdata(self.padded, is_2d=is_2d)

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.46/src/nxs_analysis_tools.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.0.45
+Version: 0.0.46
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License
         
-        Copyright (c) 2023 Steven J. Gomez Alvarado
+        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