adding self_consistency_errors property. not implemented for 3D yet

py4DSTEM/process/phase/iterative_base_class.py

@@ -2366,6 +2366,35 @@ def positions(self):
 
     @property
     def object_cropped(self):
-        """cropped and rotated object"""
+        """Cropped and rotated object"""
 
         return self._crop_rotate_object_fov(self._object)
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+
+        xp = self._xp
+        asnumpy = self._asnumpy
+
+        # Re-initialize fractional positions and vector patches, max_batch_size = None
+        self._positions_px_fractional = self._positions_px - xp.round(
+            self._positions_px
+        )
+
+        (
+            self._vectorized_patch_indices_row,
+            self._vectorized_patch_indices_col,
+        ) = self._extract_vectorized_patch_indices()
+
+        # Overlaps
+        _, _, overlap = self._overlap_projection(self._object, self._probe)
+        fourier_overlap = xp.fft.fft2(overlap)
+
+        # Normalized mean-squared errors
+        error = xp.sum(
+            xp.abs(self._amplitudes - xp.abs(fourier_overlap)) ** 2, axis=(-2, -1)
+        )
+        error /= self._mean_diffraction_intensity
+
+        return asnumpy(error)

py4DSTEM/process/phase/iterative_mixedstate_multislice_ptychography.py

@@ -3509,3 +3509,31 @@ def _return_object_fft(
 
         obj = self._crop_rotate_object_fov(np.sum(obj, axis=0))
         return np.abs(np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(obj))))
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+
+        xp = self._xp
+        asnumpy = self._asnumpy
+
+        # Re-initialize fractional positions and vector patches, max_batch_size = None
+        self._positions_px_fractional = self._positions_px - xp.round(
+            self._positions_px
+        )
+
+        (
+            self._vectorized_patch_indices_row,
+            self._vectorized_patch_indices_col,
+        ) = self._extract_vectorized_patch_indices()
+
+        # Overlaps
+        _, _, overlap = self._overlap_projection(self._object, self._probe)
+        fourier_overlap = xp.fft.fft2(overlap)
+        intensity_norm = xp.sqrt(xp.sum(xp.abs(fourier_overlap) ** 2, axis=1))
+
+        # Normalized mean-squared errors
+        error = xp.sum(xp.abs(self._amplitudes - intensity_norm) ** 2, axis=(-2, -1))
+        error /= self._mean_diffraction_intensity
+
+        return asnumpy(error)

py4DSTEM/process/phase/iterative_mixedstate_ptychography.py

@@ -2327,3 +2327,31 @@ def show_fourier_probe(
             chroma_boost=chroma_boost,
             **kwargs,
         )
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+
+        xp = self._xp
+        asnumpy = self._asnumpy
+
+        # Re-initialize fractional positions and vector patches, max_batch_size = None
+        self._positions_px_fractional = self._positions_px - xp.round(
+            self._positions_px
+        )
+
+        (
+            self._vectorized_patch_indices_row,
+            self._vectorized_patch_indices_col,
+        ) = self._extract_vectorized_patch_indices()
+
+        # Overlaps
+        _, _, overlap = self._overlap_projection(self._object, self._probe)
+        fourier_overlap = xp.fft.fft2(overlap)
+        intensity_norm = xp.sqrt(xp.sum(xp.abs(fourier_overlap) ** 2, axis=1))
+
+        # Normalized mean-squared errors
+        error = xp.sum(xp.abs(self._amplitudes - intensity_norm) ** 2, axis=(-2, -1))
+        error /= self._mean_diffraction_intensity
+
+        return asnumpy(error)

py4DSTEM/process/phase/iterative_overlap_magnetic_tomography.py

@@ -3327,3 +3327,8 @@ def positions(self):
             positions_all.append(asnumpy(positions))
 
         return np.asarray(positions_all)
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+        raise NotImplementedError()

py4DSTEM/process/phase/iterative_overlap_tomography.py

@@ -3207,3 +3207,8 @@ def positions(self):
             positions_all.append(asnumpy(positions))
 
         return np.asarray(positions_all)
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+        raise NotImplementedError()

py4DSTEM/process/phase/iterative_simultaneous_ptychography.py

@@ -3357,3 +3357,32 @@ def visualize(
             )
 
         return self
+
+    @property
+    def self_consistency_errors(self):
+        """Compute the self-consistency errors for each probe position"""
+
+        xp = self._xp
+        asnumpy = self._asnumpy
+
+        # Re-initialize fractional positions and vector patches, max_batch_size = None
+        self._positions_px_fractional = self._positions_px - xp.round(
+            self._positions_px
+        )
+
+        (
+            self._vectorized_patch_indices_row,
+            self._vectorized_patch_indices_col,
+        ) = self._extract_vectorized_patch_indices()
+
+        # Overlaps
+        _, _, overlap = self._warmup_overlap_projection(self._object, self._probe)
+        fourier_overlap = xp.fft.fft2(overlap[0])
+
+        # Normalized mean-squared errors
+        error = xp.sum(
+            xp.abs(self._amplitudes[0] - xp.abs(fourier_overlap)) ** 2, axis=(-2, -1)
+        )
+        error /= self._mean_diffraction_intensity
+
+        return asnumpy(error)