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

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.47}/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.47}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: nxs-analysis-tools
-Version: 0.0.45
+Version: 0.0.47
 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.47}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'nxs-analysis-tools'
-version = '0.0.45'
+version = '0.0.47'
 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.47}/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.47'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.47}/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.47}/src/nxs_analysis_tools/datareduction.py

@@ -16,10 +16,10 @@ 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'
-           'array_to_nxdata', 'Padder']
+                                                       '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,11 +101,13 @@ 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))))
 
 
-def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
+def plot_slice(data, X=None, Y=None, sum_axis=None, transpose=False, vmin=None, vmax=None,
                skew_angle=90, ax=None, xlim=None, ylim=None,
                xticks=None, yticks=None, cbar=True, logscale=False,
                symlogscale=False, cmap='viridis', linthresh=1,
@@ -114,6 +130,10 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
         The Y axis values. If None, a default range from 0 to the number of
          rows in `data` is used.
 
+    sum_axis : int, optional
+        If the input data is 3D, this specifies the axis to sum over in order
+        to reduce the data to 2D for plotting. Required if `data` has three dimensions.
+
     transpose : bool, optional
         If True, transpose the dataset and its axes before plotting.
         Default is False.
@@ -183,7 +203,37 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
     p : :class:`matplotlib.collections.QuadMesh`
         The `matplotlib` QuadMesh object representing the plotted data.
     """
+    is_array = False
+    is_nxdata = False
+
     if isinstance(data, np.ndarray):
+        is_array = True
+    elif isinstance(data, (NXdata, NXfield)):
+        is_nxdata = True
+    else:
+        raise TypeError(f"Unexpected data type: {type(data)}. "
+                        f"Supported types are np.ndarray and NXdata.")
+
+    # If three-dimensional, demand sum_axis to reduce to two dimensions.
+    if is_array and len(data.shape) == 3:
+        assert sum_axis is not None, "sum_axis must be specified when data is a 3D array"
+
+        data = data.sum(axis=sum_axis)
+
+    if is_nxdata and len(data.shape) == 3:
+        assert sum_axis is not None, "sum_axis must be specified when data is a 3D array"
+
+        arr = data.nxsignal.nxdata
+        arr = arr.sum(axis=sum_axis)
+
+        # Create a 2D template from the original nxdata
+        slice_obj = [slice(None)] * len(data.shape)
+        slice_obj[sum_axis] = 0
+
+        # Use the 2D template to create a new nxdata
+        data = array_to_nxdata(arr, data[slice_obj])
+
+    if is_array:
         if X is None:
             X = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='x')
         if Y is None:
@@ -193,7 +243,7 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
             data = data.transpose()
         data = NXdata(NXfield(data, name='value'), (X, Y))
         data_arr = data[data.signal].nxdata.transpose()
-    elif isinstance(data, (NXdata, NXfield)):
+    elif is_nxdata:
         if X is None:
             X = data[data.axes[0]]
         if Y is None:
@@ -202,9 +252,6 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
             X, Y = Y, X
             data = data.transpose()
         data_arr = data[data.signal].nxdata.transpose()
-    else:
-        raise TypeError(f"Unexpected data type: {type(data)}. "
-                        f"Supported types are np.ndarray and NXdata.")
 
     # Display Markdown heading
     if mdheading is None:
@@ -543,22 +590,31 @@ class Scissors:
 
         return self.linecut
 
-    def highlight_integration_window(self, data=None, label=None, highlight_color='red', **kwargs):
+    def highlight_integration_window(self, data=None, width=None, height=None, label=None, highlight_color='red',
+                                     **kwargs):
         """
-        Plots integration window highlighted on the three principal cross sections of the first
-        temperature dataset.
+        Plots the integration window highlighted on the three principal 2D cross-sections of a 3D dataset.
 
         Parameters
         ----------
         data : array-like, optional
-            The 2D heatmap dataset to plot. If not provided, the dataset stored in `self.data` will
-            be used.
+            The 3D dataset to visualize. If not provided, uses `self.data`.
+        width : float, optional
+            Width of the visible x-axis range in each subplot. Used to zoom in on the integration region.
+        height : float, optional
+            Height of the visible y-axis range in each subplot. Used to zoom in on the integration region.
         label : str, optional
-            The label for the integration window plot.
+            Label for the rectangle patch marking the integration window, used in the legend.
         highlight_color : str, optional
-            The edge color used to highlight the integration window. Default is 'red'.
-        **kwargs : keyword arguments, optional
-            Additional keyword arguments to customize the plot.
+            Color of the rectangle edges highlighting the integration window. Default is 'red'.
+        **kwargs : dict, optional
+            Additional keyword arguments passed to `plot_slice` for customizing the plot (e.g., colormap, vmin, vmax).
+
+        Returns
+        -------
+        p1, p2, p3 : matplotlib.collections.QuadMesh
+            The plotted QuadMesh objects for the three cross-sections:
+            XY at fixed Z, XZ at fixed Y, and YZ at fixed X.
 
         """
         data = self.data if data is None else data
@@ -568,7 +624,7 @@ class Scissors:
         # Create a figure and subplots
         fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
-        # Plot cross section 1
+        # Plot cross-section 1
         slice_obj = [slice(None)] * data.ndim
         slice_obj[2] = center[2]
 
@@ -587,7 +643,12 @@ class Scissors:
         )
         ax.add_patch(rect_diffuse)
 
-        # Plot cross section 2
+        if 'xlim' not in kwargs and width is not None:
+            ax.set(xlim=(center[0] - width / 2, center[0] + width / 2))
+        if 'ylim' not in kwargs and height is not None:
+            ax.set(ylim=(center[1] - height / 2, center[1] + height / 2))
+
+        # Plot cross-section 2
         slice_obj = [slice(None)] * data.ndim
         slice_obj[1] = center[1]
 
@@ -606,7 +667,12 @@ class Scissors:
         )
         ax.add_patch(rect_diffuse)
 
-        # Plot cross section 3
+        if 'xlim' not in kwargs and width is not None:
+            ax.set(xlim=(center[0] - width / 2, center[0] + width / 2))
+        if 'ylim' not in kwargs and height is not None:
+            ax.set(ylim=(center[2] - height / 2, center[2] + height / 2))
+
+        # Plot cross-section 3
         slice_obj = [slice(None)] * data.ndim
         slice_obj[0] = center[0]
 
@@ -625,6 +691,11 @@ class Scissors:
         )
         ax.add_patch(rect_diffuse)
 
+        if 'xlim' not in kwargs and width is not None:
+            ax.set(xlim=(center[1] - width / 2, center[1] + width / 2))
+        if 'ylim' not in kwargs and height is not None:
+            ax.set(ylim=(center[2] - height / 2, center[2] + height / 2))
+
         # Adjust subplot padding
         fig.subplots_adjust(wspace=0.5)
 
@@ -649,7 +720,7 @@ class Scissors:
 
         fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
-        # Plot cross section 1
+        # Plot cross-section 1
         slice_obj = [slice(None)] * data.ndim
         slice_obj[2] = center[2]
         p1 = plot_slice(data[slice_obj],
@@ -669,7 +740,7 @@ class Scissors:
                         **kwargs)
         axes[1].set_aspect(len(data[data.axes[0]].nxdata) / len(data[data.axes[2]].nxdata))
 
-        # Plot cross section 3
+        # Plot cross-section 3
         slice_obj = [slice(None)] * data.ndim
         slice_obj[0] = center[0]
         p2 = plot_slice(data[slice_obj],
@@ -999,7 +1070,7 @@ class Padder:
         self.data = data
 
         self.steps = tuple((data[axis].nxdata[1] - data[axis].nxdata[0])
-                            for axis in data.axes)
+                           for axis in data.axes)
 
         # Absolute value of the maximum value; assumes the domain of the input
         # is symmetric (eg, -H_min = H_max)

{nxs_analysis_tools-0.0.45 → nxs_analysis_tools-0.0.47}/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)