nxs-analysis-tools 0.0.41__py3-none-any.whl → 0.0.43__py3-none-any.whl

_meta/__init__.py

@@ -6,5 +6,5 @@ __author__ = 'Steven J. Gomez Alvarado'
 __email__ = 'stevenjgomez@ucsb.edu'
 __copyright__ = f"2023, {__author__}"
 __license__ = 'MIT'
-__version__ = '0.0.41'
+__version__ = '0.0.43'
 __repo_url__ = 'https://github.com/stevenjgomez/nxs_analysis_tools'

nxs_analysis_tools/chess.py

@@ -8,6 +8,7 @@ import re
 
 import matplotlib.pyplot as plt
 import matplotlib as mpl
+import pandas as pd
 import numpy as np
 from IPython.display import display, Markdown
 from nxs_analysis_tools import load_data, Scissors
@@ -190,14 +191,24 @@ class TempDependence:
 
         # Convert all temperatures to int temporarily to sort temperatures list before loading
         self.temperatures = [int(t) for t in self.temperatures]
-        self.temperatures.sort()
+
+        loading_template = pd.DataFrame({'temperature': self.temperatures, 'filename': items_to_load})
+        loading_template = loading_template.sort_values(by='temperature')
+        self.temperatures = loading_template['temperature']
         self.temperatures = [str(t) for t in self.temperatures]
+        items_to_load = loading_template['filename'].to_list()
 
         for i, item in enumerate(items_to_load):
             path = os.path.join(self.sample_directory, item)
 
             # Save dataset
-            self.datasets[self.temperatures[i]] = load_transform(path)
+            try:
+                self.datasets[self.temperatures[i]] = load_transform(path)
+            except Exception as e:
+                # Report temperature that was unable to load, then raise exception.
+                temp_failed = self.temperatures[i]
+                print(f"Failed to load data for temperature {temp_failed} K from file {item}. Error: {e}")
+                raise  # Re-raise the exception
 
             # Initialize scissors object
             self.scissors[self.temperatures[i]] = Scissors()

nxs_analysis_tools/datareduction.py

@@ -185,14 +185,14 @@ def plot_slice(data, X=None, Y=None, transpose=False, vmin=None, vmax=None,
     """
     if isinstance(data, np.ndarray):
         if X is None:
-            X = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='x')
+            X = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='x')
         if Y is None:
-            Y = NXfield(np.linspace(0, data.shape[0], data.shape[0]), name='y')
+            Y = NXfield(np.linspace(0, data.shape[1], data.shape[1]), name='y')
         if transpose:
             X, Y = Y, X
             data = data.transpose()
         data = NXdata(NXfield(data, name='value'), (X, Y))
-        data_arr = data
+        data_arr = data[data.signal].nxdata.transpose()
     elif isinstance(data, (NXdata, NXfield)):
         if X is None:
             X = data[data.axes[0]]
@@ -787,7 +787,8 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
 
         p = Padder(sliced_data)
         padding = tuple(len(sliced_data[axis]) for axis in sliced_data.axes)
-        counts = p.pad(padding).counts
+        counts = p.pad(padding)
+        counts = p.padded[p.padded.signal]
 
         counts_skewed = ndimage.affine_transform(counts,
                                                  t.inverted().get_matrix()[:2, :2],
@@ -848,7 +849,7 @@ def rotate_data(data, lattice_angle, rotation_angle, rotation_axis, printout=Fal
         elif rotation_axis == 2:
             output_array[:, :, i] = counts_unpadded
     print('\nDone.')
-    return NXdata(NXfield(output_array, name='counts'),
+    return NXdata(NXfield(output_array, name=p.padded.signal),
                   (data[data.axes[0]], data[data.axes[1]], data[data.axes[2]]))
 
 
@@ -884,7 +885,8 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
 
     p = Padder(data)
     padding = tuple(len(data[axis]) for axis in data.axes)
-    counts = p.pad(padding).counts
+    counts = p.pad(padding)
+    counts = p.padded[p.padded.signal]
 
     counts_skewed = ndimage.affine_transform(counts,
                                              t.inverted().get_matrix()[:2, :2],
@@ -937,7 +939,7 @@ def rotate_data2D(data, lattice_angle, rotation_angle):
     counts_unpadded = p.unpad(counts_unskewed)
 
     print('\nDone.')
-    return NXdata(NXfield(counts_unpadded, name='counts'),
+    return NXdata(NXfield(counts_unpadded, name=p.padded.signal),
                   (data[data.axes[0]], data[data.axes[1]]))
 
 

nxs_analysis_tools/pairdistribution.py

@@ -185,23 +185,58 @@ class Symmetrizer2D:
         q1 = data_padded[data.axes[0]]
         q2 = data_padded[data.axes[1]]
 
-        # Define signal to be symmetrized
-        counts = data_padded[data.signal].nxdata
-
         # Calculate the angle for each data point
         theta = np.arctan2(q1.reshape((-1, 1)), q2.reshape((1, -1)))
         # Create a boolean array for the range of angles
         symmetrization_mask = np.logical_and(theta >= theta_min * np.pi / 180,
                                              theta <= theta_max * np.pi / 180)
-        self.symmetrization_mask = NXdata(NXfield(p.unpad(symmetrization_mask),
-                                                  name='mask'),
-                                          (data[data.axes[0]], data[data.axes[1]])
-                                          )
 
-        self.wedge = NXdata(NXfield(p.unpad(counts * symmetrization_mask),
-                                    name=data.signal),
-                            (data[data.axes[0]], data[data.axes[1]])
-                            )
+        # Define signal to be transformed
+        counts = symmetrization_mask
+
+        # Scale and skew counts
+        skew_angle_adj = 90 - self.skew_angle
+
+        scale2 = counts.shape[0] / counts.shape[1]
+        counts_unscaled2 = ndimage.affine_transform(counts,
+                                                    Affine2D().scale(scale2, 1).inverted().get_matrix()[:2, :2],
+                                                    offset=[-(1 - scale2) * counts.shape[
+                                                        0] / 2 / scale2, 0],
+                                                    order=0,
+                                                    )
+
+        scale1 = np.cos(skew_angle_adj * np.pi / 180)
+        counts_unscaled1 = ndimage.affine_transform(counts_unscaled2,
+                                                    Affine2D().scale(scale1, 1).inverted().get_matrix()[:2, :2],
+                                                    offset=[-(1 - scale1) * counts.shape[
+                                                        0] / 2 / scale1, 0],
+                                                    order=0,
+                                                    )
+
+        mask = ndimage.affine_transform(counts_unscaled1,
+                                        t.get_matrix()[:2, :2],
+                                        offset=[-counts.shape[0] / 2
+                                                * np.sin(skew_angle_adj * np.pi / 180), 0],
+                                        order=0,
+                                        )
+
+        # Convert mask to nxdata
+        mask = array_to_nxdata(mask, data_padded)
+
+        # Save mask for user interaction
+        self.symmetrization_mask = p.unpad(mask)
+
+        # Perform masking
+        wedge = mask * data_padded
+
+        # Save wedge for user interaction
+        self.wedge = p.unpad(wedge)
+
+        # Convert wedge back to array for further transformations
+        wedge = wedge[data.signal].nxdata
+
+        # Define signal to be transformed
+        counts = wedge
 
         # Scale and skew counts
         skew_angle_adj = 90 - self.skew_angle
@@ -216,7 +251,7 @@ class Symmetrizer2D:
                                          Affine2D().scale(scale1, 1).get_matrix()[:2, :2],
                                          offset=[(1 - scale1) * counts.shape[0] / 2, 0],
                                          order=0,
-                                         ) * symmetrization_mask
+                                         )
 
         scale2 = counts.shape[0] / counts.shape[1]
         wedge = ndimage.affine_transform(wedge,
@@ -325,15 +360,24 @@ class Symmetrizer2D:
         symm_test = s.symmetrize_2d(data)
         fig, axesarr = plt.subplots(2, 2, figsize=(10, 8))
         axes = axesarr.reshape(-1)
+
+        # Plot the data
         plot_slice(data, skew_angle=s.skew_angle, ax=axes[0], title='data', **kwargs)
-        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask')
+
+        # Filter kwargs to exclude 'vmin' and 'vmax'
+        filtered_kwargs = {key: value for key, value in kwargs.items() if key not in ('vmin', 'vmax')}
+        # Plot the mask
+        plot_slice(s.symmetrization_mask, skew_angle=s.skew_angle, ax=axes[1], title='mask', **filtered_kwargs)
+
+        # Plot the wedge
         plot_slice(s.wedge, skew_angle=s.skew_angle, ax=axes[2], title='wedge', **kwargs)
+
+        # Plot the symmetrized data
         plot_slice(symm_test, skew_angle=s.skew_angle, ax=axes[3], title='symmetrized', **kwargs)
         plt.subplots_adjust(wspace=0.4)
         plt.show()
         return fig, axesarr
 
-
 class Symmetrizer3D:
     """
     A class to symmetrize 3D datasets by performing sequential 2D symmetrization on

{nxs_analysis_tools-0.0.41.dist-info → nxs_analysis_tools-0.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nxs-analysis-tools
-Version: 0.0.41
+Version: 0.0.43
 Summary: Reduce and transform nexus format (.nxs) scattering data.
 Author-email: "Steven J. Gomez Alvarado" <stevenjgomez@ucsb.edu>
 License: MIT License

nxs_analysis_tools-0.0.43.dist-info/RECORD

@@ -0,0 +1,11 @@
+_meta/__init__.py,sha256=kxRgW9usOeluI-Bk-1GiZ0pt5jesv-HKRThTZKAvTtI,352
+nxs_analysis_tools/__init__.py,sha256=bxbTLpIcKasH3fuRZOvJ9zeu7IBBju82mOTgUV4ZqHE,530
+nxs_analysis_tools/chess.py,sha256=e3ZnyepnLATXZRk2cgh6iCZ7Pk3NKJ4IvRf4xNLuu94,24984
+nxs_analysis_tools/datareduction.py,sha256=arEWF8VI8qJfT--G77OJL37C_3usjfd3-wT2gTCtwZM,41964
+nxs_analysis_tools/fitting.py,sha256=vPx75lKvm5pWOGBtRtff8k6J5dA6kRk3EJyzxCH5Tyk,8809
+nxs_analysis_tools/pairdistribution.py,sha256=8E1grptUMb4UXVT9mBSk45xk2JwjCvTG0Rl6BlbJAdo,60013
+nxs_analysis_tools-0.0.43.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
+nxs_analysis_tools-0.0.43.dist-info/METADATA,sha256=aBNS2AJAECd6RLqqQCFBjJgrW0piIhFaDxQCekvMqFc,3895
+nxs_analysis_tools-0.0.43.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nxs_analysis_tools-0.0.43.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
+nxs_analysis_tools-0.0.43.dist-info/RECORD,,

{nxs_analysis_tools-0.0.41.dist-info → nxs_analysis_tools-0.0.43.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nxs_analysis_tools-0.0.41.dist-info/RECORD

@@ -1,11 +0,0 @@
-_meta/__init__.py,sha256=QYocreoqhGDlovbW3V-ZkRa8aQqrIW5H9WvyI9XueaY,352
-nxs_analysis_tools/__init__.py,sha256=bxbTLpIcKasH3fuRZOvJ9zeu7IBBju82mOTgUV4ZqHE,530
-nxs_analysis_tools/chess.py,sha256=GUW08BcDUGD88MPZCl4yJTQp4hwd9tVNTJN_afNSUUo,24339
-nxs_analysis_tools/datareduction.py,sha256=e__mBGZIpJ-_-Dr6-T9hJURJazFnBy3PoWfwRxOra4U,41848
-nxs_analysis_tools/fitting.py,sha256=vPx75lKvm5pWOGBtRtff8k6J5dA6kRk3EJyzxCH5Tyk,8809
-nxs_analysis_tools/pairdistribution.py,sha256=bO-Ljst8eD5wmeq6oH8ylhHqaUyu2CvARznDupCygWQ,58245
-nxs_analysis_tools-0.0.41.dist-info/LICENSE,sha256=tdnoYVH1-ogW_5-gGs9bK-IkCamH1ATJqrdL37kWTHk,1102
-nxs_analysis_tools-0.0.41.dist-info/METADATA,sha256=2O7IvBuaAp_R_uXlwn-oZctEpIKGFlESR8gRAj_TP_U,3895
-nxs_analysis_tools-0.0.41.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-nxs_analysis_tools-0.0.41.dist-info/top_level.txt,sha256=8U000GNPzo6T6pOMjRdgOSO5heMzLMGjkxa1CDtyMHM,25
-nxs_analysis_tools-0.0.41.dist-info/RECORD,,