pymodaq_data 5.2.7__tar.gz → 5.2.9__tar.gz

{pymodaq_data-5.2.7 → pymodaq_data-5.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: pymodaq_data
-Version: 5.2.7
+Version: 5.2.9
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ

{pymodaq_data-5.2.7 → pymodaq_data-5.2.9}/src/pymodaq_data/data.py

@@ -949,8 +949,12 @@ class DataBase(DataLowLevel, NDArrayOperatorsMixin):
         if isinstance(epsilon, numbers.Number):
             epsilon = Q_(epsilon, self.units)
         try:
+            # using below epsilon - Q_(0, self.units) to handle units with offset/scaling like
+            # °C and °F where the diff produce a derived unit (delta_degree_Celsius) that do
+            # not compare well to epsilon itself. While epsilon - Q_(0, self.units) is not changing
+            # the value but produce similar delta units!
             return bool(np.all([np.abs(self.quantities[ind] - other.quantities[ind])
-                                <= epsilon for ind in range(len(self))]))
+                                <= (epsilon - Q_(0, self.units)) for ind in range(len(self))]))
         except pint.errors.DimensionalityError as e:
             return False
 
@@ -2795,6 +2799,10 @@ class DataWithAxes(DataBase, SerializableBase):
 
         do_squeeze = self.check_squeeze(total_slices, is_navigation)
         new_arrays_data = [squeeze(dat[total_slices], do_squeeze) for dat in self.data]
+        if self.errors is not None:
+            new_errors_data = [squeeze(dat[total_slices], do_squeeze) for dat in self.errors]
+        else:
+            new_errors_data = None
         tmp_axes = self._am.get_signal_axes() if is_navigation else self._am.get_nav_axes()
         axes_to_append = [copy.deepcopy(axis) for axis in tmp_axes]
 
@@ -2843,17 +2851,22 @@ class DataWithAxes(DataBase, SerializableBase):
         else:
             distribution = DataDistribution.uniform
 
-        data = DataWithAxes(self.name, data=new_arrays_data, nav_indexes=tuple(nav_indexes),
+        data = DataWithAxes(self.name,
+                            data=new_arrays_data,
+                            errors=new_errors_data,
+                            nav_indexes=tuple(nav_indexes),
                             axes=axes,
                             source=DataSource.calculated, origin=self.origin,
                             labels=self.labels[:],
                             distribution=distribution)
         return data
 
-    def deepcopy_with_new_data(self, data: List[np.ndarray] = None,
+    def deepcopy_with_new_data(self,
+                               data: List[np.ndarray] = None,
                                remove_axes_index: Union[int, List[int]] = None,
                                source: DataSource = DataSource.calculated,
-                               keep_dim=False) -> DataWithAxes:
+                               keep_dim=False,
+                               errors: List[np.ndarray] = None,) -> DataWithAxes:
         """deepcopy without copying the initial data (saving memory)
 
         The new data, may have some axes stripped as specified in remove_axes_index
@@ -2868,16 +2881,26 @@ class DataWithAxes(DataBase, SerializableBase):
         keep_dim: bool
             if False (the default) will calculate the new dim based on the data shape
             else keep the same (be aware it could lead to issues)
+        errors: list of numpy ndarray
+            The new errors corresponding to the new data
 
         Returns
         -------
         DataWithAxes
         """
+        def check_errors(data: list[np.ndarray], errors: list[np.ndarray]) -> bool:
+            for data_array, error_array in zip(data, errors):
+                if data_array.shape != error_array.shape:
+                    return False
+            return True
         try:
+            if errors is not None and check_errors(data, errors):
+                errors = None
             old_data = self.data
             self._data = None
             new_data = self.deepcopy()
             new_data._data = data
+            new_data.errors = errors
             new_data.get_dim_from_data(data)
 
             if source is not None:

{pymodaq_data-5.2.7 → pymodaq_data-5.2.9}/src/pymodaq_data/h5modules/data_saving.py

@@ -441,7 +441,11 @@ class DataSaverLoader(DataManagement):
             parent_node = data_node.parent_node
             data_nodes = self._get_nodes_from_data_type(parent_node)
             data_node = data_nodes[0]
-            error_node = data_node
+            error_nodes = self._error_saver._get_nodes_from_data_type(parent_node)
+            if len(error_nodes) > 0:
+                error_node = error_nodes[0]
+            else:
+                error_node = None
         else:
             parent_node = data_node.parent_node
             if not isinstance(data_node, CARRAY):
@@ -463,7 +467,7 @@ class DataSaverLoader(DataManagement):
         else:
             ndarrays = self.get_data_arrays(data_node, with_bkg=with_bkg, load_all=load_all)
             axes = self.get_axes(parent_node)
-            if error_node is not None:
+            if error_node is not None and self.data_type != DataType.error:
                 error_arrays = self._error_saver.get_data_arrays(error_node, load_all=load_all)
                 if len(error_arrays) == 0:
                     error_arrays = None
@@ -591,7 +595,9 @@ class DataEnlargeableSaver(DataSaverLoader):
                 nav_indexes = ([0] +
                                list(np.array(nav_indexes, dtype=int) + 1))
 
-                self._h5saver.add_array(where, self._get_next_node_name(where), self.data_type,
+                self._h5saver.add_array(where,
+                                        self._get_next_node_name(where),
+                                        self.data_type,
                                         title=data.name,
                                         array_to_save=data[ind_data],
                                         data_shape=data[ind_data].shape,
@@ -604,6 +610,24 @@ class DataEnlargeableSaver(DataSaverLoader):
                                                       distribution='spread',
                                                       origin=data.origin,
                                                       nav_indexes=tuple(nav_indexes)))
+                if data.errors is not None:
+                    error_dwa = data.errors_as_dwa()
+                    self._h5saver.add_array(where,
+                                            self._error_saver._get_next_node_name(where),
+                                            self._error_saver.data_type,
+                                            title=error_dwa.name,
+                                            array_to_save=error_dwa[ind_data],
+                                            data_shape=error_dwa[ind_data].shape,
+                                            array_type=error_dwa[ind_data].dtype,
+                                            enlargeable=True,
+                                            data_dimension=error_dwa.dim.name,
+                                            metadata=dict(timestamp=error_dwa.timestamp,
+                                                          label=error_dwa.labels[ind_data],
+                                                          source=error_dwa.source.name,
+                                                          distribution='spread',
+                                                          origin=error_dwa.origin,
+                                                          nav_indexes=tuple(nav_indexes)))
+
             if add_enl_axes:
                 for ind_enl_axis in range(self._n_enl_axes):
                     self._axis_saver.add_axis(where,
@@ -661,6 +685,12 @@ class DataEnlargeableSaver(DataSaverLoader):
         for ind_data in range(len(data)):
             array: EARRAY = self.get_node_from_index(where, ind_data)
             array.append(data[ind_data])
+
+            if data.errors is not None:
+                error_array: EARRAY = self._error_saver.get_node_from_index(where, ind_data)
+                error_array.append(data.errors[ind_data])
+
+
         if add_enl_axes:
             for ind_axis in range(self._n_enl_axes):
                 axis_array: EARRAY = self._axis_saver.get_node_from_index(where, ind_axis)
@@ -715,7 +745,10 @@ class DataExtendedSaver(DataSaverLoader):
                 nav_indexes = [ind for ind in range(len(self.extended_shape))] +\
                               list(np.array(nav_indexes, dtype=int) + len(self.extended_shape))
 
-                self._h5saver.add_array(where, self._get_next_node_name(where), self.data_type, title=data.name,
+                self._h5saver.add_array(where,
+                                        self._get_next_node_name(where),
+                                        self.data_type,
+                                        title=data.name,
                                         data_shape=data[ind_data].shape,
                                         array_type=data[ind_data].dtype,
                                         fill_value=self.fill_value,
@@ -727,6 +760,24 @@ class DataExtendedSaver(DataSaverLoader):
                                                       origin=data.origin,
                                                       nav_indexes=tuple(nav_indexes)))
 
+                if data.errors is not None:
+                    error_dwa = data.errors_as_dwa()
+                    self._h5saver.add_array(where,
+                                            self._error_saver._get_next_node_name(where),
+                                            self._error_saver.data_type,
+                                            title=error_dwa.name,
+                                            data_shape=error_dwa[ind_data].shape,
+                                            array_type=error_dwa[ind_data].dtype,
+                                            fill_value=self.fill_value,
+                                            scan_shape=self.extended_shape,
+                                            add_scan_dim=True,
+                                            data_dimension=error_dwa.dim.name,
+                                            metadata=dict(timestamp=error_dwa.timestamp, label=error_dwa.labels[ind_data],
+                                                          source=error_dwa.source.name, distribution=distribution.name,
+                                                          origin=error_dwa.origin,
+                                                          nav_indexes=tuple(nav_indexes)))
+
+
             if save_axes:
                 for axis in data.axes:
                     axis.index += len(self.extended_shape)
@@ -756,10 +807,13 @@ class DataExtendedSaver(DataSaverLoader):
             self._create_data_arrays(where, data, save_axes=True, distribution=distribution)
 
         for ind_data in range(len(data)):
-            #todo check that getting with index is safe...
+
             array: CARRAY = self.get_node_from_index(where, ind_data)
             array[tuple(indexes)] = data[ind_data]
             # maybe use array.__setitem__(indexes, data[ind_data]) if it's not working
+            if data.errors is not None:
+                error_array: CARRAY = self._error_saver.get_node_from_index(where, ind_data)
+                error_array[tuple(indexes)] = data.errors[ind_data]
 
 
 class DataToExportSaver:

{pymodaq_data-5.2.7 → pymodaq_data-5.2.9}/src/pymodaq_data/post_treatment/process_to_scalar.py

@@ -84,7 +84,11 @@ class StdProcessor(DataProcessorBase):
 
     def operate(self, sub_data: DataWithAxes):
         data_arrays = [np.atleast_1d(np.std(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+        if sub_data.errors is not None:
+            error_arrays = [np.atleast_1d(np.std(data, axis=sub_data.sig_indexes)) for data in sub_data.errors]
+        else:
+            error_arrays = None
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes, errors=error_arrays)
 
 
 @DataProcessorFactory.register('sum')
@@ -93,7 +97,11 @@ class SumProcessor(DataProcessorBase):
 
     def operate(self, sub_data: DataWithAxes):
         data_arrays = [np.atleast_1d(np.sum(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+        if sub_data.errors is not None:
+            error_arrays = [np.atleast_1d(np.sum(data, axis=sub_data.sig_indexes)) for data in sub_data.errors]
+        else:
+            error_arrays = None
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes, errors=error_arrays)
 
 
 @DataProcessorFactory.register('max')
@@ -102,7 +110,11 @@ class MaxProcessor(DataProcessorBase):
 
     def operate(self, sub_data: DataWithAxes):
         data_arrays = [np.atleast_1d(np.max(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+        if sub_data.errors is not None:
+            error_arrays = [np.atleast_1d(np.max(data, axis=sub_data.sig_indexes)) for data in sub_data.errors]
+        else:
+            error_arrays = None
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes, errors=error_arrays)
 
 
 @DataProcessorFactory.register('min')
@@ -111,7 +123,11 @@ class MinProcessor(DataProcessorBase):
 
     def operate(self, sub_data: DataWithAxes):
         data_arrays = [np.atleast_1d(np.min(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+        if sub_data.errors is not None:
+            error_arrays = [np.atleast_1d(np.min(data, axis=sub_data.sig_indexes)) for data in sub_data.errors]
+        else:
+            error_arrays = None
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes, errors=error_arrays)
 
 
 @DataProcessorFactory.register('argmax')